guess_centre-15 and w_spec[i] < guess_centre)) \n f_fit.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-15 and w_spec[i] < guess_centre)) \n if fit_continuum: \n c_fit=mm*np.array(w_fit)+bb \n else: \n c_fit=b*np.array(w_fit)+a \n \n fs=[]\n ws=[]\n for ii in range(len(w_fit)-1,1,-1):\n if f_fit[ii]/c_fit[ii] < 1.05 and f_fit[ii-1]/c_fit[ii-1] < 1.05 and low_limit == 0: low_limit = w_fit[ii]\n # if f_fit[ii]/c_fit[ii] < 1.05 and low_limit == 0: low_limit = w_fit[ii]\n fs.append(f_fit[ii]/c_fit[ii])\n ws.append(w_fit[ii])\n if low_limit == 0: \n sorted_by_flux=np.argsort(fs)\n try:\n low_limit = ws[sorted_by_flux[0]]\n except Exception:\n plot=True\n low_limit = 0\n \n # HIGH LIMIT \n high_limit=0\n w_fit = []\n f_fit = []\n w_fit.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre and w_spec[i] < guess_centre+15)) \n f_fit.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre and w_spec[i] < guess_centre+15)) \n if fit_continuum: \n c_fit=mm*np.array(w_fit)+bb \n else: \n c_fit=b*np.array(w_fit)+a\n \n fs=[]\n ws=[]\n for ii in range(len(w_fit)-1):\n if f_fit[ii]/c_fit[ii] < 1.05 and f_fit[ii+1]/c_fit[ii+1] < 1.05 and high_limit == 0: high_limit = w_fit[ii]\n # if f_fit[ii]/c_fit[ii] < 1.05 and high_limit == 0: high_limit = w_fit[ii]\n fs.append(f_fit[ii]/c_fit[ii])\n ws.append(w_fit[ii])\n if high_limit == 0: \n sorted_by_flux=np.argsort(fs)\n try:\n high_limit = ws[sorted_by_flux[0]] \n except Exception:\n plot=True\n high_limit = 0 \n \n # Guess centre will be the highest value in the range defined by [low_limit,high_limit]\n \n try: \n rango = np.where((high_limit >= wavelength ) & (low_limit <= wavelength)) \n index_maximo_del_rango = s.tolist().index(np.nanmax(s[rango]))\n guess_centre = wavelength[index_maximo_del_rango]\n except Exception:\n guess_centre = line #### It was 0 before\n \n \n # Fit a Gaussian to data - continuum \n p0 = [guess_centre, guess_peak, broad/2.355] # broad is the Gaussian sigma, 1.0 for emission lines\n try:\n fit, pcov = curve_fit(gauss, w_spec, f_spec-continuum, p0=p0, maxfev=10000) # If this fails, increase maxfev...\n fit_error = np.sqrt(np.diag(pcov))\n \n # New 28th Feb 2019: Check central value between low_limit and high_limit\n # Better: between guess_centre - broad, guess_centre + broad\n # If not, redo fit fixing central value to the peak (it does not work... just fix FWHM= (high_limit-low_limit)/2.5 )\n \n if verbose != False: print(\" ----------------------------------------------------------------------------------------\")\n # if low_limit < fit[0] < high_limit:\n if fit[0] < guess_centre - broad or fit[0] > guess_centre + broad:\n # if verbose: print \" Fitted center wavelength\", fit[0],\"is NOT in the range [\",low_limit,\",\",high_limit,\"]\"\n if verbose: print(\" Fitted center wavelength\", fit[0],\"is NOT in the expected range [\",guess_centre - broad,\",\",guess_centre + broad,\"]\")\n \n # print \"Re-do fitting fixing center wavelength\"\n # p01 = [guess_peak, broad]\n # fit1, pcov1 = curve_fit(gauss_fix_x0, w_spec, f_spec-continuum, p0=p01, maxfev=100000) # If this fails, increase maxfev...\n # fit_error1 = np.sqrt(np.diag(pcov1))\n # fit[0]=guess_centre\n # fit_error[0] = 0.\n # fit[1] = fit1[0]\n # fit_error[1] = fit_error1[0]\n # fit[2] = fit1[1]\n # fit_error[2] = fit_error1[1] \n \n fit[0]=guess_centre\n fit_error[0] = 0.000001\n fit[1]=guess_peak\n fit_error[1] = 0.000001\n fit[2] = broad/2.355\n fit_error[2] = 0.000001 \n else:\n if verbose: print(\" Fitted center wavelength\", fit[0],\"IS in the expected range [\",guess_centre - broad,\",\",guess_centre + broad,\"]\")\n \n \n if verbose: print(\" Fit parameters = \", fit[0], fit[1], fit[2])\n if fit[2] == broad and warnings == True : \n print(\" WARNING: Fit in\",fit[0],\"failed! Using given centre wavelength (cw), peak at (cv) & sigma = broad/2.355 given.\") \n gaussian_fit = gauss(w_spec, fit[0], fit[1], fit[2])\n \n \n # Estimate rms of the Gaussian fit in range [low_limit, high_limit]\n residuals = f_spec-gaussian_fit-continuum\n rms_fit = np.nansum([ ((residuals[i]**2)/(len(residuals)-2))**0.5 for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \n \n # Fluxes, FWHM and Eq. Width calculations\n gaussian_flux = gauss_flux(fit[1],fit[2])\n error1 = np.abs(gauss_flux(fit[1]+fit_error[1],fit[2]) - gaussian_flux)\n error2 = np.abs(gauss_flux(fit[1],fit[2]+fit_error[2]) - gaussian_flux)\n gaussian_flux_error = 1 / ( 1/error1**2 + 1/error2**2 )**0.5\n \n \n fwhm=fit[2]*2.355\n fwhm_error = fit_error[2] *2.355\n fwhm_vel = fwhm / fit[0] * C \n fwhm_vel_error = fwhm_error / fit[0] * C \n \n gaussian_ew = gaussian_flux/np.nanmedian(f_cont)\n gaussian_ew_error = gaussian_ew * gaussian_flux_error/gaussian_flux \n \n # Integrated flux\n # IRAF: flux = sum ((I(i)-C(i)) * (w(i2) - w(i1)) / (i2 - i2) \n flux = np.nansum([ (f_spec[i]-continuum[i])*(w_spec[i+1]-w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \n flux_error = rms_cont * (high_limit - low_limit)\n wave_resolution = (wavelength[-1]-wavelength[0])/len(wavelength)\n ew = wave_resolution * np.nansum ([ (1 - f_spec[i]/continuum[i]) for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \n ew_error = np.abs(ew*flux_error/flux) \n gauss_to_integrated = gaussian_flux/flux * 100.\n \n index=0\n s_s=np.zeros_like(s)\n for wave in range(len(wavelength)):\n s_s[wave]=s[wave]\n if wavelength[wave] == w_spec[0] : \n s_s[wave] = f_spec[0]-gaussian_fit[0]\n index=1\n if wavelength[wave] > w_spec[0] and wavelength[wave] <= w_spec[-1]:\n s_s[wave] = f_spec[index]-gaussian_fit[index]\n index=index+1\n \n # Plotting \n ptitle = 'Fit: x0=%.2f y0=%.2e sigma=%.2f flux=%.2e rms=%.3e' % (fit[0], fit[1], fit[2], gaussian_flux, rms_fit)\n if plot :\n plt.figure(figsize=(10, 4))\n # Plot input spectrum\n plt.plot(np.array(w_spec),np.array(f_spec), \"b\", lw=3, alpha = 0.8)\n # Plot median input spectrum\n plt.plot(np.array(w_spec),np.array(f_spec_m), \"orange\", lw=3, alpha = 0.5) # 2021: era \"g\"\n # Plot spectrum - gauss subtracted\n plt.plot(wavelength,s_s,\"g\",lw=3, alpha = 0.6)\n \n plt.minorticks_on() \n plt.xlabel(\"Wavelength [$\\mathrm{\\AA}$ ]\")\n if fcal:\n plt.ylabel(\"Flux [ erg cm$^{-2}$ s$^{-1}$ $\\mathrm{\\AA}^{-1}$ ]\")\n else:\n plt.ylabel(\"Flux [ counts ]\")\n plt.xlim(lmin,lmax)\n plt.ylim(fmin,fmax)\n \n # Vertical line at guess_centre\n plt.axvline(x=guess_centre, color='r', linestyle='-', alpha=0.3)\n # Horizontal line at y = 0\n plt.axhline(y=0, color='k', linestyle=':', alpha=0.5) \n # Dashed green regions for continuum, defined by [lowlow, lowhigh] and [highlow,highhigh]\n plt.axvspan(guess_centre+highlow, guess_centre+highhigh, facecolor='g', alpha=0.15,zorder=3)\n plt.axvspan(guess_centre-lowlow, guess_centre-lowhigh, facecolor='g', alpha=0.15,zorder=3)\n # Plot linear fit for continuum\n plt.plot(w_spec, continuum,\"g--\")\n # Plot Gaussian fit \n plt.plot(w_spec, gaussian_fit+continuum, 'r-', alpha=0.8) \n # Vertical line at Gaussian center\n plt.axvline(x=fit[0], color='k', linestyle='-', alpha=0.5)\n # Vertical lines to emission line\n plt.axvline(x= low_limit, color='k', linestyle=':', alpha=0.5)\n plt.axvline(x= high_limit, color='k', linestyle=':', alpha=0.5) \n # Plot residuals\n plt.plot(w_spec, residuals, 'k')\n plt.title(ptitle)\n plt.show()\n \n # Printing results\n if verbose :\n print(\"\\n - Gauss and continuum fitting + integrated flux calculations:\\n\")\n print(\" rms continuum = %.3e erg/cm/s/A \" % (rms_cont)) \n print(\" Gaussian Fit parameters: x0 = ( %.2f +- %.2f ) A \" % (fit[0], fit_error[0]))\n print(\" y0 = ( %.3f +- %.3f ) 1E-16 erg/cm2/s/A\" % (fit[1]/1E-16, fit_error[1]/1E-16 ))\n print(\" sigma = ( %.3f +- %.3f ) A\" % (fit[2], fit_error[2])) \n print(\" rms fit = %.3e erg/cm2/s/A\" % (rms_fit))\n print(\" Gaussian Flux = ( %.2f +- %.2f ) 1E-16 erg/s/cm2 (error = %.1f per cent)\" % (gaussian_flux/1E-16, gaussian_flux_error/1E-16, gaussian_flux_error/gaussian_flux*100))\n print(\" FWHM = ( %.3f +- %.3f ) A = ( %.1f +- %.1f ) km/s \" % (fwhm, fwhm_error, fwhm_vel, fwhm_vel_error))\n print(\" Eq. Width = ( %.1f +- %.1f ) A\" % (-gaussian_ew, gaussian_ew_error)) \n print(\"\\n Integrated flux = ( %.2f +- %.2f ) 1E-16 erg/s/cm2 (error = %.1f per cent) \" % ( flux/1E-16, flux_error/1E-16, flux_error/flux *100)) \n print(\" Eq. Width = ( %.1f +- %.1f ) A\" % (ew, ew_error))\n print(\" Gauss/Integrated = %.2f per cent \" % gauss_to_integrated)\n \n \n # Plot independent figure with substraction if requested \n if plot_sus: plot_plot(wavelength,[s,s_s], xmin=lmin, xmax=lmax, ymin=fmin, ymax=fmax, fcal=fcal, frameon=True, ptitle=ptitle)\n \n # 0 1 2 3 4 5 6 7 8 9 10 11\n resultado = [rms_cont, fit[0], fit_error[0], gaussian_flux, gaussian_flux_error, fwhm, fwhm_error, flux, flux_error, ew, ew_error, s_s ]\n return resultado \n except Exception:\n if verbose: \n print(\" - Gaussian fit failed!\")\n print(\" However, we can compute the integrated flux and the equivalent width:\")\n \n flux = np.nansum([ (f_spec[i]-continuum[i])*(w_spec[i+1]-w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \n flux_error = rms_cont * (high_limit - low_limit)\n wave_resolution = (wavelength[-1]-wavelength[0])/len(wavelength)\n ew = wave_resolution * np.nansum ([ (1 - f_spec[i]/continuum[i]) for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \n ew_error = np.abs(ew*flux_error/flux) \n \n if verbose:\n print(\" Integrated flux = ( %.2f +- %.2f ) 1E-16 erg/s/cm2 (error = %.1f per cent) \" % ( flux/1E-16, flux_error/1E-16, flux_error/flux *100)) \n print(\" Eq. Width = ( %.1f +- %.1f ) A\" % (ew, ew_error))\n \n resultado = [0, guess_centre, 0, 0, 0, 0, 0, flux, flux_error, ew, ew_error, s ] # guess_centre was identified at maximum value in the [low_limit,high_limit] range but Gaussian fit failed\n \n \n # Plotting \n if plot :\n plt.figure(figsize=(10, 4))\n plt.plot(np.array(w_spec),np.array(f_spec), \"b\", lw=3, alpha = 0.5)\n plt.minorticks_on() \n plt.xlabel(\"Wavelength [$\\mathrm{\\AA}$]\")\n if fcal:\n plt.ylabel(\"Flux [ erg cm$^{-2}$ s$^{-1}$ $\\mathrm{\\AA}^{-1}$ ]\")\n else:\n plt.ylabel(\"Flux [ counts ]\") \n plt.xlim(lmin,lmax)\n plt.ylim(fmin,fmax)\n \n # Vertical line at guess_centre\n plt.axvline(x=guess_centre, color='r', linestyle='-', alpha=0.5)\n # Horizontal line at y = 0\n plt.axhline(y=0, color='k', linestyle=':', alpha=0.5) \n # Dashed green regions for continuum, defined by [lowlow, lowhigh] and [highlow,highhigh]\n plt.axvspan(guess_centre+highlow, guess_centre+highhigh, facecolor='g', alpha=0.15,zorder=3)\n plt.axvspan(guess_centre-lowlow, guess_centre-lowhigh, facecolor='g', alpha=0.15,zorder=3)\n # Plot linear fit for continuum\n plt.plot(w_spec, continuum,\"g--\")\n # Plot Gaussian fit \n # plt.plot(w_spec, gaussian_fit+continuum, 'r-', alpha=0.8) \n # Vertical line at Gaussian center\n # plt.axvline(x=fit[0], color='k', linestyle='-', alpha=0.5)\n # Vertical lines to emission line\n plt.axvline(x= low_limit, color='k', linestyle=':', alpha=0.5)\n plt.axvline(x= high_limit, color='k', linestyle=':', alpha=0.5) \n # Plot residuals\n # plt.plot(w_spec, residuals, 'k')\n plt.title(\"No Gaussian fit obtained...\")\n plt.show()\n \n \n return resultado","def test_baseline_sinusoidal(self, b0, x0, a, freq):\n x = np.linspace(-1, 1, 100)\n y = a * np.cos(2 * np.pi * freq * (x - x0)) + b0\n\n b0_guess = guess.constant_sinusoidal_offset(y)\n\n self.assertAlmostEqual(b0, b0_guess, delta=0.1)","def f_sin(k):\n return k * k * k * pk(k, suppression)","def __generate_sin(self, phase_shift=0):\n amp = self.SIGNAL_AMPLITUDE / 2\n fs = self.sampling_freq\n duration = self.DURATION\n f = self.pinger_freq\n b = self.BIAS\n return (amp * np.sin(2 * np.pi * np.arange(fs * duration) * f / fs +\n phase_shift) + b).astype(np.float32)","def freqdomain(self):\n \n\n #self.df = self.f[1] - self.f[0]\n #frequency vector\n #fv = fftshift(fftfreq(len(eta),1./fs))\n #fv = fv[len(fv)/2:]\n \n #spectral analysis\n self.sn1 = self.espec1(self.n1)\n self.sn2 = self.espec1(self.n2)\n self.sn3 = self.espec1(self.n3)\n self.sn12 = self.espec2(self.n1,self.n2)\n self.sn13 = self.espec2(self.n1,self.n3)\n self.sn23 = self.espec2(self.n2,self.n3)\n \n #delta freq\n self.df = self.f[3] - self.f[2]\n\n #calculo do numero de onda\n #self.wavenumber()\n #k = numeronda(h,f,len(f))\n #k = np.array(k)\n\n #calculo dos coeficientes de fourier - NDBC 96_01 e Steele (1992)\n c = self.sn2[:,1] + self.sn3[:,1]\n cc = np.sqrt(self.sn1[:,1] * (c))\n \n self.a1 = self.sn12[:,3] / cc\n self.b1 = self.sn13[:,3] / cc\n \n self.a2 = (self.sn2[:,1] - self.sn3[:,1]) / c\n self.b2 = 2 * self.sn12[:,2] / c\n \n #calcula direcao de onda\n #mean direction\n self.dire1 = np.array([np.angle(np.complex(self.b1[i],self.a1[i]),deg=True) for i in range(len(self.a1))])\n \n #principal direction\n self.dire2 = 0.5 * np.array([np.angle(np.complex(self.b2[i],self.a2[i]),deg=True) for i in range(len(self.a2))])\n \n #condicao para valores maiores que 360 e menores que 0\n self.dire1[np.where(self.dire1 < 0)] = self.dire1[np.where(self.dire1 < 0)] + 360\n self.dire1[np.where(self.dire1 > 360)] = self.dire1[np.where(self.dire1 > 360)] - 360\n self.dire2[np.where(self.dire2 < 0)] = self.dire2[np.where(self.dire2 < 0)] + 360\n self.dire2[np.where(self.dire2 > 360)] = self.dire2[np.where(self.dire2 > 360)] - 360\n \n #acha o indice da frequencia de pico\n ind = np.where(self.sn1[:,1] == np.max(self.sn1[:,1]))[0]\n \n #periodo de pico\n self.tp = (1. / self.f[ind])[0]\n \n #momento espectral de ordem zero total - m0\n self.m0 = np.sum(self.sn1[:,1]) * self.df\n \n #calculo da altura significativa\n self.hm0 = 4.01 * np.sqrt(self.m0)\n \n #direcao do periodo de pico\n self.dp = self.dire1[ind][0]\n \n #Espalhamento direcional\n #Formula do sigma1 do livro Tucker&Pitt(2001) \"Waves in Ocean Engineering\" pags 196-198\n c1 = np.sqrt(self.a1 ** 2 + self.b1 ** 2)\n c2 = np.sqrt(self.a2 ** 2 + self.b2 ** 2)\n \n s1 = c1 / (1-c1)\n s2 = (1 + 3 * c2 + np.sqrt(1 + 14 * c2 + c2 ** 2)) / (2 * (1 - c2))\n \n self.sigma1 = np.sqrt(2 - 2 * c1) * 180 / np.pi\n self.sigma2 = np.sqrt((1 - c2) / 2) * 180 / np.pi\n \n self.sigma1p = np.real(self.sigma1[ind])[0]\n self.sigma2p = np.real(self.sigma2[ind])[0]\n \n # pondaf = np.array([hm0, tp, dp, sigma1p, sigma2p])\n \n #hm0, tp, dp, sigma1, sigma2, sigma1p, sigma2p, f, df, k, sn, snx, sny, snn, snnx, snny, snxny, snxnx, snyny, a1, b1, a2, b2, dire1, dire2\n #return hm0, tp, dp, sigma1, sigma2, sigma1p, sigma2p, f, df, k, sn, snx, sny, snn, snnx, snny, snxny, snxnx, snyny, a1, b1, a2, b2, dire1, dire2","def note(freq):\n data = np.sin(2.0 * np.pi * freq * t) * amp\n return data","def sinh(x):\n raise NotImplementedError","def main():\n\n #\n # Generate waveform\n #\n\n print 'generating waveoform...'\n waveform = pmns_utils.Waveform('shen_135135_lessvisc')\n\n # Pick some extrinsic parameters\n ext_params = ExtParams(distance=1, ra=0.0, dec=0.0, polarization=0.0,\n inclination=0.0, phase=0.0, geocent_peak_time=0.0+5.0)\n\n # Construct the time series for these params\n waveform.make_wf_timeseries(theta=ext_params.inclination,\n phi=ext_params.phase)\n\n #\n # Generate IFO data\n #\n det1_data = DetData(waveform=waveform, ext_params=ext_params)\n\n from scipy import signal\n import pylab as pl\n\n pl.figure()\n pl.plot(det1_data.td_response.sample_times,det1_data.td_response.data)\n pl.plot(det1_data.td_signal.sample_times,det1_data.td_signal.data)\n\n pl.figure()\n f,p = signal.welch(det1_data.td_response.data, fs=1./det1_data.delta_t,\n nperseg=512)\n pl.loglog(f,np.sqrt(p))\n\n f,p = signal.welch(det1_data.td_signal.data, fs=1./det1_data.delta_t,\n nperseg=512)\n pl.loglog(f,np.sqrt(p))\n pl.ylim(1e-25,1e-21)\n pl.show()","def calculate(Freq, f1, f2, stream, \n seconds_E, seconds_P, seconds_S, \n dt, dt_P, dt_S, Settings, dist, Acoda=None):#azBA=0):\n \n # save original trace\n original_trace = stream[0].copy()\n T0 = original_trace.stats.starttime\n \n sr = float(\"%.0f\" % original_trace.stats.sampling_rate) # 100 or 20 Hz normally\n \n if sr == 50.:\n if Settings[\"verbose\"]:\n print(\"\\nLets not use Irkut-24 digitizer data\")\n return\n \n #===\n # according to [Aki 1980] [Pavlenko 2008] [etc.]\n # нужно брать коду за фиксированныое время - например 40 с после Т0 (время в очаге)\n # однако для расстояний > 70 км, 40 сек будет раньше времени 2*Ts !\n \n #===\n # time of Coda start\n dt_Coda = dt + Acoda\n \n # how much is coda start and end in seconds\n # cut Coda from Coda1 to Coda2 - -10s back -- +10s forward (if SD == 20)\n Coda1, Coda2 = Acoda - SD/2, Acoda + SD/2\n \n # time of coda start \n dt_Coda1 = dt + Coda1\n # and End\n dt_Coda2 = dt + Coda2\n \n # check, maybe A100 < 2*Ts, then skip it\n if Acoda < (seconds_S * 2):\n if Settings[\"verbose\"]:\n print(\"\\nA`%d` amplitude is too earlier then `%.0f`!\" % (Acoda, Coda1))\n # exit only if diff > 10-15 s, cause we can use anyway 1.5*Ts\n if Acoda < (seconds_S * 2 + 10):\n return\n \n # calc SD1 manually (if not set)\n # or use fixed length for P- and S-waves\n SD1 = Settings['sd1']\n if SD1 == 0:\n # window for Direct body-waves = 0.25 * Ts\n SD1 = int( math.ceil(0.25 * seconds_S) )\n\n # P-wave window is half of S-window\n SD1P = int(math.ceil(SD1 / 2))\n \n # check: S-window and Coda-window may intersects!\n if (Coda1 - seconds_S) < SD1:\n if Settings[\"verbose\"]:\n print(\"\\nWindow S and Coda intersects for event `%s`!\" % dt)\n return\n \n #===\n # save resulting values here\n result = []\n \n # filtering\n filter_params = {'freqmin': f1, 'freqmax': f2, 'type': 'bandpass', \n 'corners': Settings[\"corners\"], 'zerophase': True}\n # Butterworth filter in place\n stream.filter(**filter_params)\n \n if Settings[\"component\"] == \"H\":\n # get ?N and ?E channels\n __N = stream.select(channel='?HN')[0].data\n __E = stream.select(channel='?HE')[0].data\n # its Hilbert transform\n hilbN = scipy.fftpack.hilbert(__N)\n hilbE = scipy.fftpack.hilbert(__E)\n # calc resulting components\n __N = np.power(__N, 2) + np.power(hilbN, 2)\n __N = np.power(__N, 0.5)\n \n __E = np.power(__E, 2) + np.power(hilbE, 2)\n __E = np.power(__E, 0.5)\n \n # and it's Average over two channels (result of calculations)\n RMS_component = np.mean( np.array([ __N, __E ]), axis=0 )\n # remove 2 components\n for _ in range(2): stream.pop(0)\n stream[0].data = RMS_component\n elif Settings[\"component\"] in (\"N\", \"E\", \"Z\"):# use just 1 channel\n # channel data\n __Z = stream.select(channel='?HZ')[0].data\n # its Hilbert transform\n hilbZ = scipy.fftpack.hilbert(__Z)\n # resulting envelope\n __Z = np.power(__Z, 2) + np.power(hilbZ, 2)\n # square root from it\n stream[0].data = np.power(__Z, 0.5)\n stream[0].stats.channel = \"RMS\"\n \n #=== start calculating\n # for Qp we use only Z-channel!!! for Qs - selected...\n assert stream.count() == 1, \"\\nMust be 1 trace! we have: %s\" % stream\n \n trace = stream[0]\n \n # check SNR on filtered signal!\n SNR, RMS_NOISE = calc_signal_noise_ratio(trace, sr, dt, dt_Coda2, 3)# 3 sec\n \n # save SNR\n result += [SNR]\n \n if SNR < Settings['minsnr']:\n if Settings[\"verbose\"]:\n print(\"\\nSNR for freq %s is too SMALL (%.1f)!...\" % (Freq, SNR))\n return result\n \n #===================================================================\n #=== Calculations\n \n # get envelope around 40 (or 100) second, aorund Acoda\n envelope_part = trace.slice(starttime=dt_Coda1, endtime=dt_Coda2)\n envelope_times = envelope_part.times() + Coda1\n \n # calc A100 value\n # just mean value like Eulenfeld does: tr.data = tr.data / np.mean(sl.data)\n y100 = np.mean(envelope_part.data) # mean value\n y100_RMS = RMS(envelope_part.data) # RMS\n \n #===\n # get filtered parts of data\n \n # P-window data\n # check that P-window and S-window do not intersects!\n if (seconds_S - seconds_P) <= SD1P:\n if Settings[\"verbose\"]:\n print(\"\\nWindow S and P intersects for %s!\" % dt)\n Pwindow = None\n else:\n Pwindow = stream.slice(dt_P, dt_P+SD1P)[0].data\n \n # S-window data\n Swindow = stream.slice(dt_S, dt_S+SD1)[0].data\n \n #===========================================================================\n # *** Crucial place for calculations ***\n \n # result for P-bulk-window\n P_window_result = get_value_for_window(Pwindow, maximum=Settings[\"max\"])\n # S-window\n S_window_result = get_value_for_window(Swindow, maximum=Settings[\"max\"])\n \n #TODO: remove coda_value, we calc RMS(Acoda), A100, A40 etc\n coda_value = 0#get_value_for_window(coda_window, maximum=Settings[\"max\"])\n \n # save results +A100 +slope koeff\n result += [P_window_result, S_window_result, coda_value, y100, y100_RMS]\n \n #===========================================================================\n #=== calculations Ended\n \n \n #===========================================================================\n # Move all plotting issues here, move out of calculating code\n #===========================================================================\n \n if PLOT:\n # make Figure\n fig, (ax1, ax2) = plt.subplots(figsize=(12, 7), nrows=2, ncols=1, sharex=True)#, dpi=200)\n \n EVENT_NAME = \"Dist = {:.0f} km | Stream {}--{} | Freq {} Hz ({}-{})\".format(dist, \n stream[0].stats.starttime, stream[0].stats.endtime, Freq, f1, f2)\n fig.suptitle(EVENT_NAME, fontsize=FONTSIZE)\n \n # plot original signal\n ax1.plot(original_trace.times(), np.abs(original_trace.data), \n color=\"grey\", lw=.5, zorder=111, label=\"NT.%s.00.BHN+BHE\" % STATION)\n # plot filtered signal\n ax1.plot(trace.times(), trace.data, \"b\", lw=1., zorder=222, label=\"RMS-envelope\")\n \n # plot filtered\n #labelFiltered = 'Фильтр {}-{} Гц'.format(f1, f2)\n ax2.semilogy(trace.times(), trace.data, \"k\", lw=0.5, zorder=222, alpha=0.75)#label=labelFiltered, \n \n # mark time of Event, P and S time by vertical lines, start -- end\n for ax in (ax1, ax2):\n ax.axvline(x=seconds_E, linestyle=\"--\", color=\"y\", lw=2.) # Event\n ax.axvline(x=seconds_P, linestyle=\"--\", color=\"b\", lw=0.5) # P\n ax.axvline(x=seconds_P+SD1P, linestyle=\"--\", color=\"b\", lw=0.5) # P+SD1p\n # S-window\n ax.axvline(x=seconds_S, linestyle=\"--\", color=\"k\", lw=1) # S\n ax.axvline(x=seconds_S+SD1, linestyle=\"--\", color=\"k\", lw=1) # S+SD1\n # mark coda\n ax.axvline(x=Coda1, linestyle=\"--\", color=\"r\", lw=2.) # coda\n ax.axvline(x=Coda2, linestyle=\"--\", color=\"r\", lw=2) # coda\n # mark noise RMS_NOISE\n ax.axhline(y=RMS_NOISE, linestyle=\"--\", color=\"c\", lw=.5) # noiz\n \n ax1.plot(Acoda, y100, \"om\", markersize=7, markeredgecolor=\"k\", zorder=9999)\n ax2.plot(Acoda, y100, \"om\", markersize=7, markeredgecolor=\"k\", zorder=9999)\n \n # mark result for S-window\n ax2.plot(seconds_S, S_window_result, \"om\", markersize=7, \n markeredgecolor=\"k\", zorder=999)\n \n # plot ec. details\n y_pos = trace.data.max() / 2\n \n #=== selected windows\n # P\n P_time = trace.times()[:Pwindow.size] + seconds_P\n ax2.plot(P_time, Pwindow, \"-r\", lw=1.)\n \n # plot S-window (Swindow)\n S_time = trace.times()[:Swindow.size] + seconds_S\n ax2.plot(S_time, Swindow, \"-r\", lw=1.)\n \n # Coda (envelope) on second axis\n ax2.plot(envelope_times, envelope_part.data, \"-r\", lw=1.)\n \n # plot SNR value text\n ax1.text(x=seconds_E+0.5, y=y_pos, s=\"%.1f\" % SNR) # SNR\n \n # maximum Coda amplitude\n ax2.text(x=Coda1, y=y100_RMS, s=\"%.1f\" % y100_RMS) #coda MAX\n \n # axis limits\n ax2.set_xlim(seconds_E - 5, Coda2 + 5)\n # y\n ax1.set_ylim(-5, original_trace.data.max())\n ax2.set_ylim(None, trace.data.max()*1.5)\n \n # legend\n ax1.legend(loc=\"best\")\n #ax2.legend(loc=\"best\")#upper right\n \n plt.tight_layout()\n \n if Settings[\"show\"]:\n plt.show()\n else:\n # just save Figure\n save_to_dir = os.path.join(\"img\", STATION, str(stream[0].stats.starttime)[:19].replace(\":\", \"-\"))\n if not os.path.exists(save_to_dir): os.makedirs(save_to_dir)\n outfilename = os.path.join(save_to_dir, \"{}_{}_{}__{}s.png\".format(STATION, Settings[\"component\"], Freq, SD))\n plt.savefig(outfilename)\n\n # the end\n return result","def sin_n(freq, frames, samplerate=SAMPLERATE):\n global PHASE\n t = np.arange(frames)/ samplerate\n out = np.sin(2 * np.pi * freq * t + PHASE).reshape(-1,1) \n PHASE += 2 * np.pi * (freq * (t[-1]+t[1])) # phase shift\n return out","def test_sinusoid():\n generator = SignalGenerator(sr=100)\n data = generator.sinusoid(noise_stds=[0, 0, 0])\n freq_features = FrequencyFeature(data, sr=100)\n freq_features.fft().peaks()\n dom_freqs = freq_features.dominant_frequency(n=1)\n dom_freqs_second = freq_features.dominant_frequency(n=2)\n assert np.allclose(dom_freqs, np.array([1, 2, 3]))\n assert np.allclose(dom_freqs_second, np.array([-1, -1, -1]))","def create_sinus_plus_brownian_noise_scenario(missing_percentage, periodparameter, scenario_name, days = 2555, seasonalperiodparam=None):\n # The stockprice is a brownian motion 7 days a week all year. \n total_days = days\n noise = b.gen_normal(days)\n days = np.arange(total_days)\n sinus = np.sin(days/periodparameter)\n noisy_sin = sinus+1.2*noise\n if(seasonalperiodparam):\n seasonal_sin = sinus = np.sin(days/seasonalperiodparam)\n noisy_sin = noisy_sin + seasonal_sin\n \n # The sp_no_missing_values will take the allyear stockprice and remove the weekends + 7 days a year random holidays.\n sin_random_missing = copy.deepcopy(noisy_sin)\n\n missing_counter = 0\n\n while(missing_counter < missing_percentage*(total_days)):\n randomday = random.randint(0, total_days-1)\n if(sin_random_missing[randomday] != np.nan):\n sin_random_missing[randomday] = np.nan\n missing_counter = missing_counter + 1\n\n plt.figure(figsize=(9,4))\n plt.plot(sin_random_missing)\n plt.legend([scenario_name],\n loc='upper left')\n if(seasonalperiodparam):\n plt.title(\"noisy sin with random 33% missing values with seasonality\")\n else:\n plt.title(\"noisy sin with every 3rd value missing\")\n\n plt.show()\n \n sin_regular_missing = copy.deepcopy(noisy_sin)\n day = 0\n while(day < total_days):\n if(day%3 == 2):\n sin_regular_missing[day] = np.nan\n day = day + 1\n\n plt.figure(figsize=(9,4))\n plt.plot(sin_regular_missing)\n plt.legend([scenario_name],\n loc='upper left')\n if(seasonalperiodparam):\n plt.title(\"noisy sin with every 3rd value missing with seasonality\")\n else:\n plt.title(\"noisy sin with every 3rd value missing\")\n plt.show()\n \n dict = {'noisy_sin': noisy_sin, 'noisy_sin_random_missing': sin_random_missing, 'noisy_sin_regular_missing': sin_regular_missing}\n df = pd.DataFrame(dict)\n if scenario_name:\n output_loc = 'synthetic_data/univariate_missingness/' + scenario_name\n df.to_csv(output_loc)\n return noisy_sin","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 test_sin_con():\n c=14\n assert {'diff':EF.sin(c).der, 'value': EF.sin(c).val}=={'diff':0, 'value': math.sin(c)}","def abrahamson_silva_ds_1999(magnitude=7.0,distance=10.0,soil=True,duration_type='DS575H'):\n\n\n # map the duration_type to integer key\n dur_map = {'DS575H': 0,\n 'DS575V': 1,\n 'DS595H': 2,\n 'DS595V': 3}\n dur_tag = dur_map.get(duration_type.upper(),None)\n if dur_tag is None:\n print(\"SignificantDurationModel.abrahamson_silva_ds_1999: duration_type='DS575H','DS575V','DS595H','DS595V'?\")\n return None, None\n # modeling coefficients\n beta = [3.2, 3.2, 3.2, 3.2]\n b1 = [5.204, 4.610, 5.204, 4.610]\n b2 = [0.851, 1.536, 0.851, 1.536]\n m_star = [6, 6, 6, 6]\n c1 = [0.805, 1.076, 0.805, 1.076]\n c2 = [0.063, 0.107, 0.063, 0.107]\n rc = [10, 10, 10, 10]\n Drat = [0.000, 0.000, 0.845, 0.646]\n sigma = [0.55, 0.46, 0.49, 0.45]\n # median\n if distance > rc[dur_tag]:\n ds_median = np.exp(np.log((np.exp(b1[dur_tag]+b2[dur_tag]* \\\n (magnitude-m_star[dur_tag]))/(10**(1.5*magnitude+ \\\n 16.05)))**(-1/3)/(4.9e6*beta[dur_tag])+soil* \\\n c1[dur_tag]+c2[dur_tag]*(distance-rc[dur_tag]))+Drat[dur_tag])\n else:\n ds_median = np.exp(np.log((np.exp(b1[dur_tag]+b2[dur_tag]* \\\n (magnitude-m_star[dur_tag]))/(10**(1.5*magnitude+ \\\n 16.05)))**(-1/3)/(4.9e6*beta[dur_tag])+soil* \\\n c1[dur_tag])+Drat[dur_tag])\n # sigma\n ds_sigma = sigma[dur_tag]\n\n # return\n return np.log(ds_median), ds_sigma","def dfluxes(wavelength, s, line1, line2, lowlow= 25, lowhigh=15, highlow=15, highhigh = 25, \n lmin=0, lmax=0, fmin=0, fmax=0,\n broad1=2.355, broad2=2.355, sus_line1=True, sus_line2=True,\n plot=True, verbose=True, plot_sus = False, fcal = True, \n fit_continuum = True, median_kernel=35, warnings = True ): # Broad is FWHM for Gaussian sigma= 1, \n # Setup wavelength limits\n if lmin == 0 :\n lmin = line1-65. # By default, +-65 A with respect to line\n if lmax == 0 :\n lmax = line2+65.\n \n # Extract subrange to fit\n w_spec = []\n f_spec = []\n w_spec.extend((wavelength[i]) for i in range(len(wavelength)) if (wavelength[i] > lmin and wavelength[i] < lmax) ) \n f_spec.extend((s[i]) for i in range(len(wavelength)) if (wavelength[i] > lmin and wavelength[i] < lmax) ) \n \n \n if np.nanmedian(f_spec) == np.nan: print(\" NO HAY DATOS.... todo son NANs!\")\n\n \n # Setup min and max flux values in subrange to fit\n if fmin == 0 :\n fmin = np.nanmin(f_spec) \n if fmax == 0 :\n fmax = np.nanmax(f_spec) \n \n\n # We have to find some \"guess numbers\" for the Gaussian\n # Now guess_centre is line\n guess_centre1 = line1\n guess_centre2 = line2 \n guess_centre = (guess_centre1+guess_centre2)/2. \n # Define continuum regions: [-lowlow, -lowhigh] and [highlow,highhigh] in Angstroms with respect to guess_centre\n \n\n w_cont=[]\n f_cont=[]\n w_cont.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-lowlow and w_spec[i] < guess_centre-lowhigh) or (w_spec[i] > guess_centre+highlow and w_spec[i] < guess_centre+highhigh) ) \n f_cont.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-lowlow and w_spec[i] < guess_centre-lowhigh) or (w_spec[i] > guess_centre+highlow and w_spec[i] < guess_centre+highhigh) ) \n\n if fit_continuum:\n # Linear Fit to continuum \n f_cont_filtered=sig.medfilt(f_cont,np.int(median_kernel))\n try: \n mm,bb = np.polyfit(w_cont, f_cont_filtered, 1)\n except Exception:\n bb = np.nanmedian(f_cont_filtered)\n mm = 0.\n if warnings: \n print(\" WARNING: Impossible to get the continuum!\")\n print(\" Scaling the continuum to the median value\") \n continuum = mm*np.array(w_spec)+bb \n c_cont = mm*np.array(w_cont)+bb \n\n else: \n # Median value in each continuum range # NEW 15 Sep 2019\n w_cont_low = []\n f_cont_low = []\n w_cont_low.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-lowlow and w_spec[i] < guess_centre-lowhigh) ) \n f_cont_low.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-lowlow and w_spec[i] < guess_centre-lowhigh) ) \n median_w_cont_low = np.nanmedian(w_cont_low)\n median_f_cont_low = np.nanmedian(f_cont_low)\n w_cont_high = []\n f_cont_high = []\n w_cont_high.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre+highlow and w_spec[i] < guess_centre+highhigh) ) \n f_cont_high.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre+highlow and w_spec[i] < guess_centre+highhigh) ) \n median_w_cont_high = np.nanmedian(w_cont_high)\n median_f_cont_high = np.nanmedian(f_cont_high) \n \n b = (median_f_cont_low-median_f_cont_high)/(median_w_cont_low-median_w_cont_high)\n a = median_f_cont_low- b * median_w_cont_low\n \n continuum = a + b*np.array(w_spec)\n c_cont = b*np.array(w_cont)+ a \n \n # rms continuum\n rms_cont = np.nansum([ np.abs(f_cont[i] - c_cont[i]) for i in range(len(w_cont)) ]) / len(c_cont)\n\n # Search for index here w_spec(index) closest to line\n min_w = np.abs(np.array(w_spec)-line1)\n mini = np.nanmin(min_w)\n guess_peak1 = f_spec[min_w.tolist().index(mini)] - continuum[min_w.tolist().index(mini)]\n min_w = np.abs(np.array(w_spec)-line2)\n mini = np.nanmin(min_w)\n guess_peak2 = f_spec[min_w.tolist().index(mini)] - continuum[min_w.tolist().index(mini)]\n\n # Search for beginning/end of emission line, choosing line +-10 \n # 28th Feb 2019: Check central value between low_limit and high_limit\n\n # LOW limit\n low_limit=0\n w_fit = []\n f_fit = []\n w_fit.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre1-15 and w_spec[i] < guess_centre1)) \n f_fit.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre1-15 and w_spec[i] < guess_centre1)) \n if fit_continuum: \n c_fit=mm*np.array(w_fit)+bb \n else: \n c_fit=b*np.array(w_fit)+a\n \n\n fs=[]\n ws=[]\n for ii in range(len(w_fit)-1,1,-1):\n if f_fit[ii]/c_fit[ii] < 1.05 and f_fit[ii-1]/c_fit[ii-1] < 1.05 and low_limit == 0: low_limit = w_fit[ii]\n# if f_fit[ii]/c_fit[ii] < 1.05 and low_limit == 0: low_limit = w_fit[ii]\n fs.append(f_fit[ii]/c_fit[ii])\n ws.append(w_fit[ii])\n if low_limit == 0: \n sorted_by_flux=np.argsort(fs)\n low_limit = ws[sorted_by_flux[0]]\n \n # HIGH LIMIT \n high_limit=0\n w_fit = []\n f_fit = []\n w_fit.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre2 and w_spec[i] < guess_centre2+15)) \n f_fit.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre2 and w_spec[i] < guess_centre2+15)) \n if fit_continuum: \n c_fit=mm*np.array(w_fit)+bb \n else: \n c_fit=b*np.array(w_fit)+a\n \n fs=[]\n ws=[]\n for ii in range(len(w_fit)-1):\n if f_fit[ii]/c_fit[ii] < 1.05 and f_fit[ii+1]/c_fit[ii+1] < 1.05 and high_limit == 0: high_limit = w_fit[ii]\n# if f_fit[ii]/c_fit[ii] < 1.05 and high_limit == 0: high_limit = w_fit[ii]\n fs.append(f_fit[ii]/c_fit[ii])\n ws.append(w_fit[ii])\n if high_limit == 0: \n sorted_by_flux=np.argsort(fs)\n high_limit = ws[sorted_by_flux[0]] \n \n # Fit a Gaussian to data - continuum \n p0 = [guess_centre1, guess_peak1, broad1/2.355, guess_centre2, guess_peak2, broad2/2.355] # broad is the Gaussian sigma, 1.0 for emission lines\n try:\n fit, pcov = curve_fit(dgauss, w_spec, f_spec-continuum, p0=p0, maxfev=10000) # If this fails, increase maxfev...\n fit_error = np.sqrt(np.diag(pcov))\n\n\n # New 28th Feb 2019: Check central value between low_limit and high_limit\n # Better: between guess_centre - broad, guess_centre + broad\n # If not, redo fit fixing central value to the peak (it does not work... just fix FWHM= (high_limit-low_limit)/2.5 )\n\n if verbose != False: print(\" ----------------------------------------------------------------------------------------\")\n if fit[0] < guess_centre1 - broad1 or fit[0] > guess_centre1 + broad1 or fit[3] < guess_centre2 - broad2 or fit[3] > guess_centre2 + broad2:\n if warnings: \n if fit[0] < guess_centre1 - broad1 or fit[0] > guess_centre1 + broad1: \n print(\" Fitted center wavelength\", fit[0],\"is NOT in the expected range [\",guess_centre1 - broad1,\",\",guess_centre1 + broad1,\"]\")\n else:\n print(\" Fitted center wavelength\", fit[0],\"is in the expected range [\",guess_centre1 - broad1,\",\",guess_centre1 + broad1,\"]\")\n if fit[3] < guess_centre2 - broad2 or fit[3] > guess_centre2 + broad2: \n print(\" Fitted center wavelength\", fit[3],\"is NOT in the expected range [\",guess_centre2 - broad2,\",\",guess_centre2 + broad2,\"]\")\n else:\n print(\" Fitted center wavelength\", fit[3],\"is in the expected range [\",guess_centre2 - broad2,\",\",guess_centre2 + broad2,\"]\")\n print(\" Fit failed!\")\n \n fit[0]=guess_centre1\n fit_error[0] = 0.000001\n fit[1]=guess_peak1\n fit_error[1] = 0.000001\n fit[2] = broad1/2.355\n fit_error[2] = 0.000001 \n fit[3]=guess_centre2\n fit_error[3] = 0.000001\n fit[4]=guess_peak2\n fit_error[4] = 0.000001\n fit[5] = broad2/2.355\n fit_error[5] = 0.000001\n else:\n if warnings: print(\" Fitted center wavelength\", fit[0],\"is in the expected range [\",guess_centre1 - broad1,\",\",guess_centre1 + broad1,\"]\")\n if warnings: print(\" Fitted center wavelength\", fit[3],\"is in the expected range [\",guess_centre2 - broad2,\",\",guess_centre2 + broad2,\"]\")\n \n\n if warnings: \n print(\" Fit parameters = \", fit[0], fit[1], fit[2]) \n print(\" \", fit[3], fit[4], fit[5])\n if fit[2] == broad1/2.355 and warnings == True : \n print(\" WARNING: Fit in\",fit[0],\"failed! Using given centre wavelengths (cw), peaks at (cv) & sigmas=broad/2.355 given.\") # CHECK THIS \n\n gaussian_fit = dgauss(w_spec, fit[0], fit[1], fit[2],fit[3], fit[4], fit[5])\n \n gaussian_1 = gauss(w_spec, fit[0], fit[1], fit[2])\n gaussian_2 = gauss(w_spec, fit[3], fit[4], fit[5])\n \n\n # Estimate rms of the Gaussian fit in range [low_limit, high_limit]\n residuals = f_spec-gaussian_fit-continuum\n rms_fit = np.nansum([ ((residuals[i]**2)/(len(residuals)-2))**0.5 for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \n \n # Fluxes, FWHM and Eq. Width calculations # CHECK THIS , not well done for dfluxes !!!\n \n gaussian_flux_1 = gauss_flux(fit[1],fit[2])\n gaussian_flux_2 = gauss_flux(fit[4],fit[5]) \n gaussian_flux = gaussian_flux_1+ gaussian_flux_2 \n if warnings: \n print(\" Gaussian flux = \", gaussian_flux_1, \" + \",gaussian_flux_2,\" = \",gaussian_flux)\n print(\" Gaussian ratio = \", gaussian_flux_1/gaussian_flux_2)\n \n error1 = np.abs(gauss_flux(fit[1]+fit_error[1],fit[2]) - gaussian_flux)\n error2 = np.abs(gauss_flux(fit[1],fit[2]+fit_error[2]) - gaussian_flux)\n gaussian_flux_error = 1 / ( 1/error1**2 + 1/error2**2 )**0.5\n \n fwhm=fit[2]*2.355\n fwhm_error = fit_error[2] *2.355\n fwhm_vel = fwhm / fit[0] * C \n fwhm_vel_error = fwhm_error / fit[0] * C \n \n gaussian_ew = gaussian_flux/np.nanmedian(f_cont)\n gaussian_ew_error = gaussian_ew * gaussian_flux_error/gaussian_flux \n \n # Integrated flux\n # IRAF: flux = sum ((I(i)-C(i)) * (w(i2) - w(i1)) / (i2 - i2) \n flux = np.nansum([ (f_spec[i]-continuum[i])*(w_spec[i+1]-w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \n flux_error = rms_cont * (high_limit - low_limit)\n wave_resolution = (wavelength[-1]-wavelength[0])/len(wavelength)\n ew = wave_resolution * np.nansum ([ (1 - f_spec[i]/continuum[i]) for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \n ew_error = np.abs(ew*flux_error/flux) \n gauss_to_integrated = gaussian_flux/flux * 100.\n \n # Plotting \n if plot :\n plt.figure(figsize=(10, 4))\n #Plot input spectrum\n plt.plot(np.array(w_spec),np.array(f_spec), \"blue\", lw=2, alpha = 0.7)\n plt.minorticks_on() \n plt.xlabel(\"Wavelength [$\\mathrm{\\AA}$]\")\n if fcal:\n plt.ylabel(\"Flux [ erg cm$^{-2}$ s$^{-1}$ $\\mathrm{\\AA}^{-1}$ ]\")\n else:\n plt.ylabel(\"Flux [ counts ]\")\n plt.xlim((line1+line2)/2-40,(line1+line2)/2+40)\n plt.ylim(fmin,fmax)\n \n # Vertical line at guess_centre\n plt.axvline(x=guess_centre1, color='r', linestyle='-', alpha=0.5)\n plt.axvline(x=guess_centre2, color='r', linestyle='-', alpha=0.5)\n\n # Horizontal line at y = 0\n plt.axhline(y=0, color='k', linestyle=':', alpha=0.5) \n # Dashed green regions for continuum, defined by [lowlow, lowhigh] and [highlow,highhigh]\n plt.axvspan(guess_centre+highlow, guess_centre+highhigh, facecolor='g', alpha=0.15,zorder=3)\n plt.axvspan(guess_centre-lowlow, guess_centre-lowhigh, facecolor='g', alpha=0.15,zorder=3)\n # Plot linear fit for continuum\n plt.plot(w_spec, continuum,\"g--\")\n # Plot Gaussian fit \n plt.plot(w_spec, gaussian_fit+continuum, 'r-', alpha=0.8) \n # Vertical line at Gaussian center\n plt.axvline(x=fit[0], color='k', linestyle='-', alpha=0.5)\n plt.axvline(x=fit[3], color='k', linestyle='-', alpha=0.5)\n # Plot Gaussians + cont\n plt.plot(w_spec, gaussian_fit+continuum, 'r-', alpha=0.5, lw=3) \n plt.plot(w_spec, gaussian_1+continuum, color=\"navy\",linestyle='--', alpha=0.8)\n plt.plot(w_spec, gaussian_2+continuum, color=\"#1f77b4\",linestyle='--', alpha=0.8)\n plt.plot(w_spec, np.array(f_spec)-(gaussian_fit), 'orange', alpha=0.4, linewidth=5) \n\n # Vertical lines to emission line\n plt.axvline(x= low_limit, color='k', linestyle=':', alpha=0.5)\n plt.axvline(x= high_limit, color='k', linestyle=':', alpha=0.5) \n plt.title('Double Gaussian Fit') # Fit: x0=%.2f y0=%.2e sigma=%.2f flux=%.2e rms=%.3e' % (fit[0], fit[1], fit[2], gaussian_flux, rms_fit))\n plt.show()\n plt.close()\n \n # Plot residuals\n# plt.figure(figsize=(10, 1))\n# plt.xlabel(\"Wavelength [$\\mathrm{\\AA}$]\")\n# plt.ylabel(\"RMS\")\n# plt.xlim((line1+line2)/2-40,(line1+line2)/2+40)\n# plt.axvline(x=fit[0], color='k', linestyle='-', alpha=0.5)\n# plt.axvline(x=fit[3], color='k', linestyle='-', alpha=0.5)\n# plt.plot(w_spec, residuals, 'k')\n# plt.minorticks_on()\n# plt.show()\n# plt.close()\n\n \n # Printing results\n if verbose :\n #print \"\\n> WARNING !!! CAREFUL WITH THE VALUES PROVIDED BELOW, THIS TASK NEEDS TO BE UPDATED!\\n\"\n print(\"\\n> Gauss and continuum fitting + integrated flux calculations:\\n\")\n print(\" rms continuum = %.3e erg/cm/s/A \" % (rms_cont)) \n print(\" Gaussian Fit parameters: x0 = ( %.2f +- %.2f ) A \" % (fit[0], fit_error[0]))\n print(\" y0 = ( %.3f +- %.3f ) 1E-16 erg/cm2/s/A\" % (fit[1]/1E-16, fit_error[1]/1E-16 ))\n print(\" sigma = ( %.3f +- %.3f ) A\" % (fit[2], fit_error[2])) \n print(\" rms fit = %.3e erg/cm2/s/A\" % (rms_fit))\n print(\" Gaussian Flux = ( %.2f +- %.2f ) 1E-16 erg/s/cm2 (error = %.1f per cent)\" % (gaussian_flux/1E-16, gaussian_flux_error/1E-16, gaussian_flux_error/gaussian_flux*100))\n print(\" FWHM = ( %.3f +- %.3f ) A = ( %.1f +- %.1f ) km/s \" % (fwhm, fwhm_error, fwhm_vel, fwhm_vel_error))\n print(\" Eq. Width = ( %.1f +- %.1f ) A\" % (-gaussian_ew, gaussian_ew_error)) \n print(\"\\n Integrated flux = ( %.2f +- %.2f ) 1E-16 erg/s/cm2 (error = %.1f per cent) \" % ( flux/1E-16, flux_error/1E-16, flux_error/flux *100)) \n print(\" Eq. Width = ( %.1f +- %.1f ) A\" % (ew, ew_error))\n print(\" Gauss/Integrated = %.2f per cent \" % gauss_to_integrated)\n \n \n # New 22 Jan 2019: sustract Gaussian fit\n index=0\n s_s=np.zeros_like(s)\n sustract_this = np.zeros_like(gaussian_fit)\n if sus_line1:\n sustract_this = sustract_this + gaussian_1\n if sus_line2:\n sustract_this = sustract_this + gaussian_2 \n \n \n for wave in range(len(wavelength)):\n s_s[wave]=s[wave]\n if wavelength[wave] == w_spec[0] : \n s_s[wave] = f_spec[0]-sustract_this[0]\n index=1\n if wavelength[wave] > w_spec[0] and wavelength[wave] <= w_spec[-1]:\n s_s[wave] = f_spec[index]-sustract_this[index]\n index=index+1\n if plot_sus: \n plt.figure(figsize=(10, 4))\n plt.plot(wavelength,s, \"r\")\n plt.plot(wavelength,s_s, \"c\")\n plt.minorticks_on() \n plt.xlabel(\"Wavelength [$\\mathrm{\\AA}$]\")\n if fcal:\n plt.ylabel(\"Flux [ erg cm$^{-2}$ s$^{-1}$ $\\mathrm{\\AA}^{-1}$ ]\")\n else:\n plt.ylabel(\"Flux [ counts ]\")\n plt.xlim(lmin,lmax)\n plt.ylim(fmin,fmax)\n plt.show()\n plt.close()\n \n # This gaussian_flux in 3 is gaussian 1 + gaussian 2, given in 15, 16, respectively\n # 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16\n resultado = [rms_cont, fit[0], fit_error[0], gaussian_flux, gaussian_flux_error, fwhm, fwhm_error, flux, flux_error, ew, ew_error, s_s, fit[3], fit[4],fit[5], gaussian_flux_1, gaussian_flux_2 ]\n return resultado \n except Exception:\n if verbose: print(\" Double Gaussian fit failed!\")\n resultado = [0, line1, 0, 0, 0, 0, 0, 0, 0, 0, 0, s, 0, 0, 0, 0, 0 ] # line was identified at lambda=line but Gaussian fit failed\n\n # NOTA: PUEDE DEVOLVER EL FLUJO INTEGRADO AUNQUE FALLE EL AJUSTE GAUSSIANO...\n\n # Plotting \n if plot :\n plt.figure(figsize=(10, 4))\n plt.plot(np.array(w_spec),np.array(f_spec), \"b\", lw=3, alpha = 0.5)\n plt.minorticks_on() \n plt.xlabel(\"Wavelength [$\\mathrm{\\AA}$]\")\n if fcal:\n plt.ylabel(\"Flux [ erg cm$^{-2}$ s$^{-1}$ $\\mathrm{\\AA}^{-1}$ ]\")\n else:\n plt.ylabel(\"Flux [ counts ]\") \n plt.xlim(lmin,lmax)\n plt.ylim(fmin,fmax)\n \n # Vertical line at guess_centre\n plt.axvline(x=guess_centre, color='r', linestyle='-', alpha=0.5)\n # Horizontal line at y = 0\n plt.axhline(y=0, color='k', linestyle=':', alpha=0.5) \n # Dashed green regions for continuum, defined by [lowlow, lowhigh] and [highlow,highhigh]\n plt.axvspan(guess_centre+highlow, guess_centre+highhigh, facecolor='g', alpha=0.15,zorder=3)\n plt.axvspan(guess_centre-lowlow, guess_centre-lowhigh, facecolor='g', alpha=0.15,zorder=3)\n # Plot linear fit for continuum\n plt.plot(w_spec, continuum,\"g--\")\n # Plot Gaussian fit \n# plt.plot(w_spec, gaussian_fit+continuum, 'r-', alpha=0.8) \n # Vertical line at Gaussian center\n# plt.axvline(x=fit[0], color='k', linestyle='-', alpha=0.5)\n # Vertical lines to emission line\n plt.axvline(x= low_limit, color='k', linestyle=':', alpha=0.5)\n plt.axvline(x= high_limit, color='k', linestyle=':', alpha=0.5) \n # Plot residuals\n# plt.plot(w_spec, residuals, 'k')\n plt.title(\"No Gaussian fit obtained...\")\n plt.show()\n\n\n return resultado","def test_Morlet():\n morl = cw.MorletWave()\n assert(np.isclose(morl(0), np.pi**(-1/4), atol=1.e-12))\n assert(np.isclose(morl.freq(0), 0, atol=1.e-12))","def test_get_spectra_bi():\r\n\r\n methods = (None,\r\n {\"this_method\": 'welch', \"NFFT\": 256, \"Fs\": 2 * np.pi},\r\n {\"this_method\": 'welch', \"NFFT\": 1024, \"Fs\": 2 * np.pi})\r\n\r\n for method in methods:\r\n arsig1, _, _ = utils.ar_generator(N=2 ** 16)\r\n arsig2, _, _ = utils.ar_generator(N=2 ** 16)\r\n\r\n avg_pwr1 = (arsig1 ** 2).mean()\r\n avg_pwr2 = (arsig2 ** 2).mean()\r\n avg_xpwr = (arsig1 * arsig2.conjugate()).mean()\r\n\r\n tseries = np.vstack([arsig1, arsig2])\r\n\r\n f, fxx, fyy, fxy = tsa.get_spectra_bi(arsig1, arsig2, method=method)\r\n\r\n # \\sum_{\\omega} PSD(\\omega) d\\omega:\r\n est_pwr1 = np.sum(fxx * (f[1] - f[0]))\r\n est_pwr2 = np.sum(fyy * (f[1] - f[0]))\r\n est_xpwr = np.sum(fxy * (f[1] - f[0])).real\r\n\r\n # Test that we have the right order of magnitude:\r\n npt.assert_array_almost_equal(est_pwr1, avg_pwr1, decimal=-1)\r\n npt.assert_array_almost_equal(est_pwr2, avg_pwr2, decimal=-1)\r\n npt.assert_array_almost_equal(np.mean(est_xpwr),\r\n np.mean(avg_xpwr),\r\n decimal=-1)","def test_freq(self):\n model = BDF(debug=False)\n sid = 101\n freqs = 0.1\n freq = model.add_freq(sid, freqs, comment='freq')\n #print(freq)\n\n freqs = [2.0, 3.0]\n freq = model.add_freq(sid, freqs, comment='freq')\n #print(freq)\n\n f1 = 0.\n df = 2.0\n freq1 = model.add_freq1(sid, f1, df, ndf=5, comment='freq1')\n assert len(freq1.freqs) == 6, 'freqs=%s' % freq1.freqs\n #print(freq1)\n\n f1 = 1.\n f2 = 8.0\n freq2 = model.add_freq2(sid, f1, f2, nf=6, comment='freq2')\n assert len(freq2.freqs) == 7, 'freqs=%s' % freq2.freqs\n assert np.allclose(freq2.freqs.max(), f2), freq2.freqs\n #print(freq2)\n\n freq4 = model.add_freq4(sid, f1, f2, fspread=0.1, nfm=3, comment='freq4')\n #print(model.frequencies[sid])\n #print(freq4)\n\n fractions = [0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]\n freq5 = model.add_freq5(sid, fractions, f1=0., f2=100., comment='freq5')\n\n fractions = np.linspace(0., 1.)\n unused_freq5b = model.add_freq5(sid, fractions, f1=0., f2=100., comment='freq5')\n model.validate()\n\n freq.raw_fields()\n freq.write_card()\n freq.write_card(size=16)\n\n freq1.raw_fields()\n freq1.write_card()\n freq1.write_card(size=16)\n\n freq2.raw_fields()\n freq2.write_card()\n freq2.write_card(size=16)\n\n freq4.raw_fields()\n freq4.write_card()\n freq4.write_card(size=16)\n\n freq5.raw_fields()\n freq5.write_card()\n freq5.write_card(size=16)\n\n bdf_file = StringIO()\n model.write_bdf(bdf_file, close=False)\n unused_out = bdf_file.getvalue()\n bdf_file.seek(0)\n\n model2 = read_bdf(bdf_file, punch=True, debug=False)\n model2.uncross_reference()\n model2.safe_cross_reference()\n model2.uncross_reference()\n save_load_deck(model)","def create_sinus_scenario(missing_percentage, periodparameter, scenario_name):\n # The stockprice is a brownian motion 7 days a week all year. \n total_days = 1460\n days = np.arange(total_days)\n sinus = np.sin(days/periodparameter)\n\n # The sp_no_missing_values will take the allyear stockprice and remove the weekends + 7 days a year random holidays.\n sin_missing_values = copy.deepcopy(sinus)\n\n\n missing_counter = 0\n\n while(missing_counter < missing_percentage*(total_days)):\n randomday = random.randint(0, total_days)\n if(sin_missing_values[randomday] != np.nan):\n sin_missing_values[randomday] = np.nan\n missing_counter = missing_counter + 1\n\n plt.figure(figsize=(9,4))\n plt.plot(sin_missing_values)\n plt.legend([scenario_name],\n loc='upper left')\n plt.show()\n\n \n dict = {'sinus': sinus, 'noisy_sin_missing_values': sin_missing_values} \n df = pd.DataFrame(dict)\n output_loc = 'synthetic_data/sinus_scenarios/' + scenario_name\n df.to_csv(output_loc)\n return noisy_sin","def setUp(self):\n shape = RNG.integers(5, 50)\n periods = self.periods = RNG.normal() * 3\n freq = periods / shape\n amp = RNG.normal()\n offset = RNG.normal()\n phase = (RNG.normal() - 1 / 2) * 5 / 3 * np.pi\n p_gt = self.p_gt = (amp, freq, phase, offset)\n x = self.x = np.arange(shape)\n self.data = sine(x, *p_gt)","def sinh(self):\t\t\n\t\tval = np.sinh(self.val)\n\t\tif len(self.der.shape):\n\t\t\tto_multiply = np.cosh(self.val)\n\t\t\tto_multiply = np.expand_dims(to_multiply, 1) if len(self.der.shape) > len(to_multiply.shape) else to_multiply\n\t\t\tder = to_multiply * self.der\n\t\telse:\n\t\t\tder = None\n\t\treturn Var(val, der)","def sin_transition(freq1, freq2, frames, samplerate=SAMPLERATE):\n global PHASE\n\n t = np.arange(frames)/ samplerate\n G = (freq2*t*t - freq1*(t[-1]-t)*(t[-1]-t))/2/t[-1] + t[-1]/2*freq1 # integrates (1-t)f1 + t*f2\n out = np.sin(2 * np.pi * G + PHASE).reshape(-1,1) \n PHASE += 2 * np.pi * (G[-1] + freq2*t[1]) # phase shift\n return out","def sinh(x):\n return 0.0","def test_lightcurve_seismology_plot():\n KeplerLightCurveFile(TABBY_Q8).PDCSAP_FLUX.periodogram().plot()","def sin_transition4(freq1, freq2, frames, start_idx=0, samplerate=SAMPLERATE):\n t = (start_idx + np.arange(frames)) / samplerate\n t = t.reshape(-1, 1)\n phase = (freq2*(t-t[0])*(t-t[0]) - freq1*(t[-1]-t)*(t[-1]-t))/2/(t[-1]-t[0]) \n return np.sin(2 * np.pi * phase).reshape(-1,1)","def sincbroad(w, s, hwhm):\n \"\"\"\n History\n -------\n Dec-90 GB,GM\n Rewrote with fourier convolution algorithm.\n Jul-91 AL\n Translated from ANA to IDL.\n 22-Sep-91 JAV\n Relaxed constant dispersion check# vectorized, 50% faster.\n 05-Jul-92 JAV\n Converted to function, handle nonpositive hwhm.\n 14-Nov-93 JAV\n Adapted from macbro.pro\n 23-Apr-93 JAV\n Verified that convolution kernel has specified hwhm. For IR FTS\n spectra: hwhm=0.0759 Angstroms, max change in profile is 0.4% of continuum.\n Oct-18 AW\n Python Version\n \"\"\"\n\n # Warn user if hwhm is negative.\n if hwhm < 0:\n logger.warning(\"Forcing negative smoothing width to zero.\")\n\n # Return input argument if half-width is nonpositive.\n if hwhm <= 0:\n return s # true: no broadening\n\n # Calculate (uniform) dispersion.\n nw = len(w) ## points in spectrum\n dw = (w[-1] - w[0]) / (nw - 1) # wavelength change per pixel\n\n # Make sinc function out to 20th zero-crossing on either side. Error due to\n # ignoring additional lobes is less than 0.2% of continuum. Reducing extent\n # to 10th zero-crossing doubles maximum error.\n fwhm = 2.0 * hwhm # full width at half maximum\n rperfw = 0.26525 # radians per fwhm of sinc\n xrange = 20 * np.pi # 20th zero of sinc (radians)\n wrange = xrange * fwhm * rperfw # 20th zero of sinc (wavelength)\n nhalf = int(wrange / dw + 0.999) ## points in half sinc\n nsinc = 2 * nhalf + 1 ## points in sinc (odd!)\n wsinc = (np.arange(nsinc, dtype=float) - nhalf) * dw # absissca (wavelength)\n xsinc = wsinc / (fwhm * rperfw) # absissca (radians)\n xsinc[nhalf] = 1.0 # avoid divide by zero\n sinc = np.sin(xsinc) / xsinc # calculate sinc\n sinc[nhalf] = 1.0 # insert midpoint\n xsinc[nhalf] = 0.0 # fix xsinc\n sinc = sinc / np.sum(sinc) # normalize sinc\n\n # Pad spectrum ends to minimize impact of Fourier ringing.\n sout = convolve(s, sinc, mode=\"nearest\")\n\n return sout","def sin(data):\n return _make.sin(data)","def oscillator(freq: float, sec: float, rate: int = 441000):\n phases = np.cumsum(2.0 * np.pi * freq / rate * np.ones(int(rate * sec)))\n return np.sin(phases)","def line_sSFR(**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n GR = glo.global_results()\n \n L_line = getattr(GR,'L_'+p.line+'_sun')#[0:100]\n SFR = getattr(GR,'SFR')#[0:100]\n Zsfr = getattr(GR,'Zsfr')#[0:100]\n R_gas = getattr(GR,'R2_gas')#[0:100]\n M_H2 = getattr(GR,'M_H2_R2_gas')#[0:100]\n M_star = getattr(GR,'M_star')#[0:100]\n\n # Take only MS galaxies?\n if p.select == '_MS':\n indices = aux.select_salim18(GR.M_star,GR.SFR)\n L_line = L_line[indices]\n SFR = SFR[indices]\n Zsfr = Zsfr[indices]\n print('With MS selection criteria: only %i galaxies' % (len(L_line)))\n\n SFR = SFR[L_line > 0]\n Zsfr = Zsfr[L_line > 0]\n R_gas = R_gas[L_line > 0]\n M_H2 = M_H2[L_line > 0]\n M_star = M_star[L_line > 0]\n sSFR = SFR/M_star\n L_line = L_line[L_line > 0]\n\n print('%i data points ' % (len(L_line)))\n\n labs = {'_M10':'Mach=10 power-law',\\\n '_arepoPDF_dim':'AREPO parametric PDF with extinction',\\\n '_arepoPDF':'AREPO parametric PDF'}\n lab = labs[p.table_ext]\n\n if p.add:\n ax = p.ax\n else:\n fig,ax = plt.subplots(figsize=(8,6))\n\n if p.select == 'Sigma_M_H2':\n Sigma_M_H2 = M_H2/(np.pi*R_gas**2)\n m = ax.scatter(sSFR[np.argsort(Sigma_M_H2)],L_line[np.argsort(Sigma_M_H2)],marker='o',s=20,\\\n c=np.log10(Sigma_M_H2[np.argsort(Sigma_M_H2)]),vmin=3.5,label=lab,alpha=0.6,zorder=10)\n cbar = plt.colorbar(m,ax=ax)\n cbar.set_label(label=r'log $\\Sigma_{H2}$ [M$_{\\odot}$/kpc$^2$]',size=15)\n else:\n m = ax.scatter(sSFR,L_line,marker='o',s=20,\\\n c=Zsfr,label=lab,alpha=0.6,zorder=10)\n cbar = plt.colorbar(m,ax=ax)\n cbar.set_label(label=r'$\\langle Z\\rangle_{\\mathrm{SFR}}$ [Z$_{\\odot}$]',size=15)\n\n if p.add_obs:\n add_line_sSFR_obs(p.line,L_line,ax,select=p.select)\n\n ax.set_xscale('log')\n ax.set_yscale('log')\n ax.set_xlabel(getlabel('sSFR'))\n ax.set_ylabel(getlabel(p.line))\n handles,labels = ax.get_legend_handles_labels()\n handles = np.flip(handles)\n labels = np.flip(labels)\n # ax.legend(handles,labels,loc='upper left',fontsize=7)\n ax.legend(handles,labels,loc='lower right',fontsize=7,frameon=True,framealpha=0.5) \n print(np.min(sSFR),np.max(sSFR))\n if not p.xlim: p.xlim = 10.**np.array([-13,-7])\n if not p.ylim: \n p.ylim = [np.median(L_line)/1e6,np.median(L_line)*1e4]\n ax.set_xlim(p.xlim)\n ax.set_ylim(p.ylim)\n ax.grid(ls='--')\n\n if p.savefig & (not p.add):\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \n plt.savefig(p.d_plot + 'luminosity/%s_sSFR.png' % p.line, format='png', dpi=300)","def flatNoisePellicle():\n #Get data\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/' \\\n 'NoiseStudy/SolarBwPellicle/'\n d1,dx1 = met.read4DFits(wdir+'161209_Avg8_Meas1.fits')\n d2,dx2 = met.read4DFits(wdir+'161209_Avg8_Meas2.fits')\n d3,dx3 = met.read4DFits(wdir+'161209_Avg8_Meas3.fits')\n d4,dx4 = met.read4DFits(wdir+'161209_Avg8_Meas4.fits')\n\n #Construct power spectra\n f12,pow12 = fourier.meanPSD((d1-d2)[:,100:-100],\\\n win=np.hanning,dx=dx1,irregular=True)\n f23,pow23 = fourier.meanPSD((d2-d3)[:,100:-100],\\\n win=np.hanning,dx=dx1,irregular=True)\n f34,pow34 = fourier.meanPSD((d3-d4)[:,100:-100],\\\n win=np.hanning,dx=dx1,irregular=True)\n f14,pow14 = fourier.meanPSD((d1-d4)[:,100:-100],\\\n win=np.hanning,dx=dx1,irregular=True)\n\n #Mid frequency\n midfreq = [1000*np.sqrt(np.sum(p[np.logical_and(f>.1,f<1.)])) \\\n for f,p in zip([f12,f23,f34,f14],[pow12,pow23,pow34,pow14])]\n\n #Plot\n plt.loglog(f12,pow12/f12[0],label='1-2: %.2f' % midfreq[0])\n plt.loglog(f23,pow23/f23[0],label='2-3: %.2f' % midfreq[1])\n plt.loglog(f34,pow34/f34[0],label='3-4: %.2f' % midfreq[2])\n plt.loglog(f14,pow14/f14[0],label='1-4: %.2f' % midfreq[3])\n plt.legend(loc='lower left')\n plt.grid()\n plt.title('4D Repeatability: SolarB Flat+Pellicle')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n\n print midfreq\n\n return f12,pow12","def test_double_sinusoid():\n generator = SignalGenerator(sr=100)\n data1 = generator.sinusoid(noise_stds=[0.1, 0.1, 0.1])\n data2 = generator.sinusoid(dom_freqs=[0.1, 0.2, 0.3], amps=[0.1, 0.2, 0.3])\n data = data1 + data2\n freq_features = FrequencyFeature(data, sr=100)\n freq_features.fft().peaks()\n dom_freqs = freq_features.dominant_frequency(n=1)\n dom_freqs_second = freq_features.dominant_frequency(n=2)\n dom_freqs_third = freq_features.dominant_frequency(n=3)\n assert np.allclose(dom_freqs, np.array([1, 2, 3]))\n assert np.allclose(dom_freqs_second, np.array([0.1, 0.2, 0.3]))\n assert np.allclose(dom_freqs_third, np.array([-1, -1, -1]))","def sinh(data):\n return _make.sinh(data)","def one_transition_spectrum_fluor(self,tr):\n \n\n ta = tr[\"ta\"] # TimeAxis\n dd = tr[\"dd\"] # transition dipole strength\n om = tr[\"om\"] # frequency - rwa\n gg = tr[\"gg\"] # natural broadening (constant or time dependent)\n fwhm = tr[\"fwhm\"] # Additional gaussian broadening of the spectra\n sgm = fwhm/(2*numpy.sqrt(2*numpy.log(2)))\n \n # CD and fluorescence can be calculated in this step\n # TODO if rotatory strength defined calculate also circular dichroism spectra\n # TOOD calculate fluorescence spectra (for fluorescence there should be a switch because it should be calculated only for the first transition) \n \n \n if self.system._has_system_bath_coupling:\n# ct = tr[\"ct\"] # correlation function\n re = tr[\"re\"] # reorganisation energy\n \n # convert correlation function to lineshape function\n #gt = self._c2g(ta,ct.data)\n gt = tr[\"gt\"]\n # calculate time dependent response\n at = numpy.exp(-numpy.conjugate(gt) -1j*om*ta.data + 2j*re*ta.data)\n else:\n # calculate time dependent response\n at = numpy.exp(-1j*om*ta.data) \n# plt.figure()\n# plt.title(\"Absorption\")\n# plt.plot(ta.data,numpy.real(at))\n# plt.plot(ta.data,numpy.imag(at))\n \n \n if len(gg) == 1:\n gam = gg[0]\n rt = numpy.exp(gam*ta.data)\n at *= rt\n #print(\"Constant: \", rt[20], len(at))\n else:\n rt = numpy.exp((gg)*ta.data) \n at *= rt\n #print(\"Time dependent: len = \", rt[20], len(rt))\n \n if fwhm!=0.0:\n gauss = numpy.exp(-2*(numpy.pi**2)*(sgm**2)*(ta.data**2))\n at *= gauss\n \n # Fourier transform the result\n ft = dd*numpy.fft.hfft(at)*ta.step\n ft = numpy.fft.fftshift(ft)\n # invert the order because hfft is a transform with -i\n ft = numpy.flipud(ft) \n # cut the center of the spectrum\n Nt = ta.length #len(ta.data) \n return ft[Nt//2:Nt+Nt//2]","def sinh(a):","def notebook_01():\n\n freq_list, volt_list = las.load_freq_volt()\n\n n_steps, n_det, n_f, _ = np.shape(volt_list)\n\n #y_sym_mat_o = ds.by_sym_mat(volt_list, det_ind=0)\n #y_sym_mat_i = ds.by_sym_mat(volt_list, det_ind=1)\n\n # print(np.shape(y_sym_mat_o))\n # print(np.shape(y_sym_mat_i))\n # (mu_o, sigma_o) = stats.norm.fit(y_sym_mat_o[:,0])\n # (mu_i, sigma_i) = stats.norm.fit(y_sym_mat_i[:,0])\n # print(mu_o, sigma_o)\n # print(mu_i, sigma_i)\n # print(mu_o*89000, mu_i*89000.0, -mu_i*89000.0, -mu_o*89000.0)\n\n volt_list_sym = ds.volt_list_sym_calc(volt_list)\n\n fit_params_mat = fp.fit_params(ff.f_b_field, volt_list_sym)\n\n fit_params_mat_s = fp.fit_params(ff.f_b_field_off, volt_list_sym)\n\n # pbd.plot_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\n\n # pfp.plot_fit_sym_comp(volt_list_sym, fit_params_mat, fit_params_mat_s, freq_list)\n\n\n # pfp.plot_fit_sym_comp_2(volt_list_sym, fit_params_mat_s, freq_list)\n\n #pfp.plot_symmetry_along_z(volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\n\n fp.fit_params_FH_data(ff.f_b_field)\n\n # pbd.plot_rel_diff_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)","def Sin_Discrete(a,b,F,A = 1,f = 1):\t\t\t\t\t\t\t\t\t# Function to generate Discrete Sinusoid\t\n\ttime = np.arange(a,b,1)\n\tamplitude = A*np.sin(2*np.pi*time*f/F)\n\t\n\treturn amplitude,time","def Sin_Discrete(a,b,F,A = 1,f = 1):\t\t\t\t\t\t\t\t\t# Function to generate Discrete Sinusoid\t\n\ttime = np.arange(a,b,1)\n\tamplitude = A*np.sin(2*np.pi*time*f/F)\n\t\n\treturn amplitude,time","def test_FEMM_periodicity_angle():\n\n SPMSM_015 = load(join(DATA_DIR, \"Machine\", \"SPMSM_015.json\"))\n\n assert SPMSM_015.comp_periodicity() == (9, False, 9, True)\n\n simu = Simu1(name=\"test_FEMM_periodicity_angle\", machine=SPMSM_015)\n\n # Definition of the enforced output of the electrical module\n I0_rms = 250 / sqrt(2)\n Phi0 = 140 * pi / 180 # Maximum Torque Per Amp\n\n Id_ref = (I0_rms * exp(1j * Phi0)).real\n Iq_ref = (I0_rms * exp(1j * Phi0)).imag\n\n simu.input = InputCurrent(\n Id_ref=Id_ref,\n Iq_ref=Iq_ref,\n Na_tot=252 * 9,\n Nt_tot=4 * 9,\n N0=1000,\n )\n\n # Definition of the magnetic simulation: with periodicity\n simu.mag = MagFEMM(\n type_BH_stator=1,\n type_BH_rotor=1,\n is_periodicity_a=True,\n is_periodicity_t=False,\n nb_worker=cpu_count(),\n Kmesh_fineness=2,\n )\n simu.force = ForceMT()\n\n # Definition of the magnetic simulation: no periodicity\n # Definition of the magnetic simulation: no periodicity\n simu2 = simu.copy()\n simu2.mag.is_periodicity_a = False\n\n simu2.force = ForceMT()\n\n # Run simulations\n out = Output(simu=simu)\n simu.run()\n\n out2 = Output(simu=simu2)\n simu2.run()\n\n # Plot the result\n out.mag.B.plot_2D_Data(\n \"time\",\n \"angle[0]{°}\",\n data_list=[out2.mag.B],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_B_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.B.plot_2D_Data(\n \"angle{°}\",\n \"time[1]\",\n data_list=[out2.mag.B],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_B_space.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.force.AGSF.plot_2D_Data(\n \"wavenumber=[0,100]\",\n \"time[0]\",\n data_list=[out2.force.AGSF],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_P_space_fft.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.force.AGSF.plot_2D_Data(\n \"freqs\",\n \"angle[0]\",\n data_list=[out2.force.AGSF],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_P_fft2.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.Tem.plot_2D_Data(\n \"time\",\n data_list=[out2.mag.Tem],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_Tem_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.Phi_wind_stator.plot_2D_Data(\n \"time\",\n \"phase\",\n data_list=[out2.mag.Phi_wind_stator],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_Phi_wind_stator_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n # Compare both simu\n Bflux = out.mag.B\n arg_list = [\"angle\"]\n result = Bflux.get_rphiz_along(*arg_list)\n Brad = result[\"radial\"]\n angle = result[\"angle\"]\n\n Bflux2 = out2.mag.B\n arg_list = [\"angle\"]\n result2 = Bflux2.get_rphiz_along(*arg_list)\n Brad2 = result2[\"radial\"]\n\n assert_array_almost_equal(Brad, Brad2, decimal=1)\n\n return out, out2","def test_synth_simple():\n \n twd = tempfile.mkdtemp(dir=os.getcwd()+\"/tmp\")\n print(twd)\n \n wmin, wmax, dwl = 6700, 6720, 0.01\n ll = turbopy.TSLineList(os.path.join(data_path, \"vald-6700-6720.list\"))\n atmo = turbopy.MARCSModel.load(os.path.join(data_path, \"sun.mod\"))\n atmo.Teff = 5777\n atmo.logg = 4.44\n atmo.MH = 0.0\n atmo.AM = 0.0\n wave, norm, flux = turbopy.run_synth(wmin, wmax, dwl,\n atmosphere=atmo, vt=1.0,\n linelist=ll, twd=twd)\n \n wave2, norm2, flux2 = turbopy.run_synth(wmin, wmax, dwl,\n [12.0, 0.4], [6.0, 1.0], [8.0, 1.0],\n atmosphere=atmo, vt=1.0,\n linelist=ll, twd=twd)\n \"\"\"\n import matplotlib.pyplot as plt\n fig = plt.figure()\n plt.plot(wave, norm, 'k-', lw=3)\n plt.plot(wave, norm2, 'r-', lw=1)\n fig.savefig(\"test3.pdf\")\n plt.close(fig)\n \"\"\"","def find_signal_morphology(rr_intervals, fs: float = 4):\n baseline = calculate_time_features(rr_intervals=rr_intervals)['baseline']\n vhr = rr_intervals - baseline\n accel_values = np.sort(vhr[vhr > 15]) # Change for right value\n decel_values = np.sort(vhr[vhr < -15]) # Change for right value\n accel_args = np.zeros(accel_values.shape, dtype=int)\n decel_args = np.zeros(decel_values.shape, dtype=int)\n acceleration_array = []\n deceleration_array = []\n k = 0\n for i, x in enumerate(vhr):\n if x in accel_values:\n accel_args[k] = int(i)\n k += 1\n # Make acceleration array of tuples (start, end)\n if np.sum(accel_values > 0):\n start = accel_args[0]\n end = accel_args[0]\n for i in range(len(accel_args) - 1):\n if (accel_args[i + 1] - accel_args[i] >= 2) or (i + 1 == len(accel_args) - 1):\n acceleration_array.append((start, end))\n start = accel_args[i + 1]\n else:\n end = accel_args[i + 1]\n # Make deceleration array of tuples (start, end)\n k = 0\n for i, x in enumerate(vhr):\n if x in decel_values:\n decel_args[k] = i\n k += 1\n if np.sum(decel_values < 0) > 2:\n start = decel_args[0]\n end = decel_args[0]\n for i in range(len(decel_args) - 1):\n if (decel_args[i + 1] - decel_args[i] >= 2) or (i + 1 == len(decel_args)):\n deceleration_array.append((start, end))\n start = decel_args[i + 1]\n else:\n end = decel_args[i + 1]\n delete_array = np.concatenate((accel_args, decel_args))\n vhr_pure = np.delete(vhr, delete_array)\n AmpStd = np.sqrt(np.mean(np.square(vhr_pure)))\n return baseline, AmpStd, acceleration_array, deceleration_array","def create_sinus_plus_stochastic_noise_scenario(missing_percentage, periodparameter, scenario_name):\n # The stockprice is a brownian motion 7 days a week all year. \n total_days = 1460\n noise = s.gen_normal(1460)\n days = np.arange(total_days)\n sinus = np.sin(days/periodparameter)\n noisy_sin = sinus+0.15*noise\n\n # The sp_no_missing_values will take the allyear stockprice and remove the weekends + 7 days a year random holidays.\n sin_missing_values = copy.deepcopy(noisy_sin)\n\n missing_counter = 0\n\n while(missing_counter < missing_percentage*(total_days)):\n randomday = random.randint(0, total_days)\n if(sin_missing_values[randomday] != np.nan):\n sin_missing_values[randomday] = np.nan\n missing_counter = missing_counter + 1\n\n plt.figure(figsize=(9,4))\n plt.plot(sin_missing_values)\n plt.legend([scenario_name],\n loc='upper left')\n plt.show()\n\n \n dict = {'noisy_sin': noisy_sin, 'noisy_sin_missing_values': sin_missing_values} \n df = pd.DataFrame(dict)\n output_loc = 'synthetic_data/sinus_scenarios/' + scenario_name\n df.to_csv(output_loc)\n return noisy_sin","def sin(x):\n raise NotImplementedError","def sinh(obj):\n\tif isinstance(obj, Variable):\n\t\tval = np.sinh(obj.val)\n\t\tder = np.cosh(obj.val)\n\t\tif len(obj.der.shape)>len(der.shape):\n\t\t\tder = np.expand_dims(der,1)\n\t\tder = np.multiply(der, obj.der)\n\t\treturn Variable(val, der)\n\telse:\n\t\treturn np.sinh(obj)","def bruno_mes(self):\n MI = -125\n MA = 125\n INCR = 19\n####################################################################\n ### CHANNEL 1\n self.write('CHN 1')\n self.write('CHN?')\n print 'Acting on channel:',self.read()\n self.write('WAVE ARB')\n self.write('ARBLOAD ARB1')\n self.write('FREQ 100')\n self.write('DCOFFS 0.05')\n self.write('AMPL 0.1')\n \n l =(125,-125,125)#arange(MI,MA,INCR) # the ramp\n# lll = copy(l)[::-1][1:-1]\n# l = concatenate((l,lll))\n self.write_array_to_byte(l,1)","def flatNoiseCGH():\n #Get data\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/NoiseStudy/FlatMeasurements/'\n d1,dx1 = met.read4DFits(wdir+'161205_RefFlat_Avg8_Meas1.fits')\n d2,dx2 = met.read4DFits(wdir+'161205_RefFlat_Avg8_Meas2.fits')\n p1,px1 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestPitch_Meas1.fits')\n p2,px2 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestPitch_Meas2.fits')\n p3,px3 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestRoll_Meas1.fits')\n p4,px4 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestRoll_Meas2.fits')\n\n #Construct baseline power spectra\n f1,pow1 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1)\n f2,pow2 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1,axis=1)\n \n #Construct parroted power spectra\n f3,pow3 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx1)\n f4,pow4 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx2,axis=1)\n f5,pow5 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx1)\n f6,pow6 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx2,axis=1)\n\n #Plot\n plt.loglog(f1,pow1/f1[0],label='Axial Baseline')\n plt.loglog(f2,pow2/f2[0],label='Azimuthal Baseline')\n plt.loglog(f3,pow3/f3[0],label='Pitch Axial')\n plt.loglog(f4,pow4/f4[0],label='Pitch Azimuthal')\n plt.loglog(f5,pow5/f5[0],label='Roll Axial')\n plt.loglog(f6,pow6/f6[0],label='Roll Azimuthal')\n plt.title('Residual Fringe Repeatability Impact')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n plt.legend(loc='lower left')\n\n return f1,pow1","def build_oblique_foF2_observed_by_radar(rad=\"cvw\", dates=[dt.datetime(2017,8,21), dt.datetime(2017,8,21)], bmnum=11, scan_num=1,\n remove_first_range=800, remove_last_range=2500, power_drop=10., plot=True):\n csv_fname = \"data/{rad}_{start}_{end}.csv\".format(rad=rad, start=dates[0].strftime(\"%Y.%m.%d.%H.%M\"), \n end=dates[1].strftime(\"%Y.%m.%d.%H.%M\"))\n if not os.path.exists(csv_fname):\n fdata = FetchData( rad, [dates[0], dates[1]] )\n s_params = [\"noise.sky\", \"tfreq\", \"frang\", \"rsep\", \"scan\", \"bmnum\"]\n v_params = [\"slist\", \"v\", \"w_l\", \"p_l\", \"elv\"]\n _, scans = fdata.fetch_data(by=\"scan\", s_params=s_params, v_params=v_params)\n beams = []\n # Resacle tx_frequency and estimate slant range \n for scan in scans:\n for beam in scan.beams:\n if len(beam.slist) > 0:\n setattr(beam, \"slant_range\", beam.frang + np.array(beam.slist.tolist()) * beam.rsep)\n setattr(beam, \"tfreq\", np.round(beam.tfreq/1e3,1))\n beams.append(beam)\n # Extract oblique foF2 or MUF scan by scan\n print(\"\\n Data will be averaged over {} scans\".format(scan_num))\n print(\" Processing beam {}\".format(bmnum))\n print(\" Remove first range {}\".format(remove_first_range))\n print(\" Remove last range {}\".format(remove_last_range))\n print(\" Power drop {}\".format(power_drop))\n skip_distance, o_foF2, time_start, time_end = [], [], [], []\n for i in range(len(scans)-scan_num):\n rscan = scans[i:i+scan_num]\n p_l, srange, tfrq, angle = [], [], [], []\n for scan in rscan:\n for beam in scan.beams:\n if beam.bmnum == bmnum:\n if len(beam.slist) > 0:\n p_l.extend(beam.p_l.tolist())\n srange.extend(beam.slant_range.tolist())\n tfrq.append(beam.tfreq)\n if type(beam.elv) is list: angle.extend(beam.elv)\n else: angle.extend(beam.elv.tolist())\n du = pd.DataFrame()\n du[\"p_l\"], du[\"srange\"] = p_l, srange\n du = du[(du.srange>remove_first_range) & (du.srange<remove_last_range)]\n fname = \"images/{}.png\".format(rscan[0].stime.strftime(\"%Y-%m-%d-%H-%M\"))\n if len(du) > 0:\n sd = fit_lambda(du, power_drop, tfreq=np.mean(tfrq), elv=np.mean(angle).round(1), \n xlabel=\"srange\", ylabel=\"p_l\", fname=fname, plot=plot)\n if sd != np.nan:\n skip_distance.append(sd)\n o_foF2.append(np.mean(tfrq))\n time_start.append(rscan[0].stime)\n time_end.append(rscan[-1].stime)\n df = pd.DataFrame()\n df[\"skip_distance\"], df[\"o_foF2\"], df[\"time_start\"], df[\"time_end\"] = skip_distance, o_foF2, time_start, time_end\n df.to_csv(csv_fname, index=False, header=True)\n else: df = pd.read_csv(csv_fname, parse_dates=[\"time_start\", \"time_end\"])\n print(\" Header:\\n\",df.head())\n return df","def OxygenTransmission(T,P,n_wv,wavelength,dr,freq_lim=np.array([lp.c/770e-9,lp.c/768e-9]),sim_nu=np.array([]),spec_file=''):\n # fraction of O2 by number density\n fO2 = (32*0.2320+28.02*0.7547+44.01*0.00046+39.94*0.0128+20.18*0.000012+4.0*0.0000007+83.8*0.000003+131.29*0.00004)*0.2320/32.0\n \n if len(spec_file) == 0:\n spec_file = '/Users/mhayman/Documents/DIAL/O2_HITRAN2012_760_781.txt'\n \n if sim_nu.size==0:\n sim_nu = np.arange(-3e9,3e9,20e6)\n \n# inu0 = np.argmin(np.abs(sim_nu)) # index to center of frequency array\n \n n_o2=fO2*(P/(lp.kB*T)-n_wv) # to convert atm to Pa use *101325\n ext_o2 = rb.ExtinctionFromHITRAN(lp.c/wavelength+sim_nu,T,P,(mO2*1e-3)/lp.N_A,nuLim=freq_lim,freqnorm=True,filename=spec_file).T\n T_o2 = np.exp(-np.cumsum(n_o2[np.newaxis,:]*ext_o2,axis=1)*dr)\n \n return T_o2,sim_nu","def f_sin(k):\n return k * pk(k, suppression)","def spectrum(datapath, run, forcebins = False):\n runpath = datapath + '/' + run\n events = [evnt for evnt in listdir(runpath) if not isfile(join(runpath,evnt))]\n allTraces = []\n total_time = 0\n pulses = {'zero': [], 'one': [], 'two': [], 'three': [], 'other': []}\n times = {'zero': [], 'one': [], 'two': [], 'three': [], 'other': []}\n #camextratime = 25e-6\n for event in events:\n if int(event)> 3:\n break\n print(event)\n e = sbc.DataHandling.GetSBCEvent.GetEvent(runpath,event)\n if e[\"slowDAQ\"][\"loaded\"]:\n #print(e[\"fastDAQ\"].keys())\n cgate = e[\"fastDAQ\"][\"CAMgate\"]\n #dcam = np.diff(cgate)\n fdt = e['fastDAQ']['time']\n #camOffTimes = np.sort(np.array([fdt[i] for i in range(len(dcam)) if dcam[i] > 0.5]))\n \n #camOnTimes = np.sort(np.array([fdt[i] for i in range(len(dcam)) if dcam[i] < 0.5]))\n fddt = fdt[1]-fdt[0]\n tfast = fdt[-1]-fdt[0]\n LED_on = [fdt[i] for i in range(len(cgate)) if cgate[i]<-0.5]\n blockedFraction = ((len(LED_on)*fddt))/tfast\n print(blockedFraction)\n tr = e[\"PMTtraces\"]\n trac = tr[\"traces\"]\n dt = tr[\"dt\"]\n #event_time = (tr['t0_sec'][-1]+tr['t0_frac'][-1]-tr['t0_sec'][0] - tr['t0_frac'][0])[0]\n event_time = (((e[\"slowDAQ\"][\"elapsed_time\"][-1]-e[\"slowDAQ\"][\"elapsed_time\"][0]))*(1-blockedFraction))\n #print(event_time)\n total_time += event_time\n\n #f,axes = plt.subplots(1,5,sharey=True)\n #f.suptitle(runpath+\"/\"+str(event))\n #pmttracetime = e[\"PMTtraces\"][\"t0_sec\"][:,0]+e[\"PMTtraces\"][\"t0_frac\"][:,0]\n #d=sbc.AnalysisModules.PMTfastDAQalignment.PMTandFastDAQalignment(e)\n #pmtalign = d[\"PMT_trigt0_sec\"]+d[\"PMT_trigt0_frac\"]\n #tracetimes = pmttracetime - pmtalign\n #camoffindex = 0\n #camonindex = 0\n for i in range(len(trac)):\n #print(i)\n \"\"\"\n thistracetime = tracetimes[i]\n \n #nearestcamoff = min(camOffTimes, key=lambda x:abs(x-thistracetime))\n #nearestcamon = min(camOnTimes, key=lambda x:abs(x-thistracetime))\n print(camOffTimes[camoffindex])\n print(thistracetime)\n if thistracetime > camOffTimes[camoffindex]:\n camoffindex += 1\n if thistracetime > camOnTimes[camonindex]:\n camonindex += 1 \n if camoffindex<len(camOffTimes)-1:\n if abs(camOffTimes[camoffindex]-thistracetime)<camextratime:\n print('excluding a trace near a camera off')\n continue\n if camonindex<len(camOnTimes)-1:\n if abs(camOnTimes[camonindex]-thistracetime)<camextratime:\n print('excluding a trace near a camera on')\n continue\n \"\"\"\n trace = np.fabs(trac[i][0])\n if max(trace) == 128:\n trace = stitchTraces(trace,np.fabs(e[\"PMTtraces\"][\"traces\"][i][1]))\n dt_tr = dt[i][0]\n\n # populate dictionaries arrays based on how many pulses there were\n [a,n,totInt,pktimes] = SBC_pulse_integrator_bressler(trace,dt_tr)\n if n == 0:\n number = 'zero'\n allTraces.append(a)\n elif n == 1:\n number = 'one'\n allTraces.append(a)\n times['one'].append(pktimes[0])\n elif n == 2:\n number = 'two'\n allTraces.append(a)\n elif n == 3:\n number = 'three'\n allTraces.append(a)\n else:\n number = 'other'\n allTraces.append(a)\n \"\"\"\n #if a != None:\n if isZero:\n if j < 5:\n if isNegative:\n if random() >0:\n print(runpath+\"/\"+str(event)+\" pmt trace \"+str(i))\n tPMT = np.arange(len(trace))*dt_tr\n axes[j].plot(tPMT,trace,lw=3)\n axes[j].set_xlabel(\"time (s)\",fontsize=25)\n axes[j].set_ylabel(\"PMT response (ADC)\",fontsize=25)\n j+=1\n \n \n plt.show\n \"\"\"\n pulses[number].append(a)\n gc.collect()\n \n \n for k in pulses:\n pulses[k] = [x for x in pulses[k] if x != None]\n \n allTraces = [x for x in allTraces if x != None]\n \n plt.figure()\n\n Nbins = int(np.floor(np.sqrt(len(allTraces))))\n allvals, bins, _ = plt.hist(allTraces,Nbins,label='all traces')\n \n areaVals = {'zero': [], 'one': [], 'two': [], 'three': [], 'other': []}\n for k in pulses:\n if k != 'other':\n areaVals[k], _, _ = plt.hist(pulses[k],bins,histtype = 'step',\n linewidth = 3,label= k+' hits')\n plt.legend(fontsize=12)\n plt.show() \n #spe_spectrum = areaVals['one']\n \n #def gaussian(x,mu,sigma,amplitude):\n # return amplitude * np.exp(-((x - mu) /(np.sqrt(2)* sigma))**2 )\n \n #params_spe, params_cov_spe = scipy.optimize.curve_fit(gaussian,bins[:len(areaVals['one'])],\n # spe_spectrum,\n # p0=[0.4e8,1e7,40])\n #params_twohits, params_cov_twohits = scipy.optimize.curve_fit(gaussian,\n # bins[:len(areaVals['two'])],\n # areaVals['two'],\n # p0=[0.8e8,1e7,10])\n #mu_spe = params_spe[0]\n #mu_2 = params_twohits[0] - mu_spe\n #print(mu_spe)\n #print(mu_2)\n \n #mu_avg = (mu_spe + mu_2)*0.5\n #mu_avg = get_gain(datapath,run)\n mu_avg = 1e7\n print(mu_avg)\n\n \n plt.figure()\n plt.grid(True)\n if isinstance(forcebins,np.ndarray):\n bins=forcebins\n fullspect,_,_=plt.hist([t/mu_avg for t in allTraces],\n forcebins,label='all traces')\n \n else:\n fullspect,bins,_=plt.hist([t/mu_avg for t in allTraces],\n int(np.floor(np.sqrt(len(allTraces)))),label='all traces')\n \n #print(bins)\n plt.yscale('log')\n plt.xlabel('phe based on a gain of '+str(mu_avg)+' electrons per phe')\n plt.legend()\n plt.show\n print(sum(fullspect)/total_time)\n print(\"The Total Exposure Time of run \"+str(runpath)+ \" was \"+str(total_time)+\" Seconds\")\n print(\"The overall PMT trigger rate was \" + str(len(allTraces)/total_time)+ \"Hz\")\n return [fullspect,bins,total_time]","def sinwave(scene):\n # create an empty homogeneous transformation\n matrix = np.eye(4)\n # set Y as cos of time\n matrix[1][3] = np.cos(time.time()) * 2\n # set Z as sin of time\n matrix[2][3] = np.sin(time.time()) * 3\n\n # take one of the two spheres arbitrarily\n node = s.graph.nodes_geometry[0]\n # apply the transform to the node\n scene.graph.update(node, matrix=matrix)","def sin(fs: float, Ns: int, Ss: int) -> np.ndarray:\n t = np.arange(Ns)\n omega = 2 * np.pi * fs / Ss\n return np.sin(omega * t)","def test_atm_psf_fft(self):\n config = {\n 'psf': {\n 'type': 'AtmosphericPSF'\n },\n 'gal': {\n 'type': 'DeltaFunction',\n 'flux': 1e5,\n 'sed': {\n 'file_name': 'vega.txt',\n 'wave_type': 'nm',\n 'flux_type': 'fnu',\n },\n },\n 'input': {\n 'atm_psf': {\n 'airmass': self.opsim_data['airmass'],\n 'rawSeeing': self.opsim_data['rawSeeing'],\n 'band': self.opsim_data['band'],\n 'screen_size': 409.6,\n 'boresight': {\n 'type': 'RADec',\n 'ra': { 'type': 'Degrees', 'theta': self.opsim_data['rightascension'], },\n 'dec': { 'type': 'Degrees', 'theta': self.opsim_data['declination'], }\n }\n }\n },\n 'stamp': {\n 'type': 'LSST_Silicon',\n\n 'fft_sb_thresh': 2.e5, # When to switch to fft and a simpler PSF and skip silicon\n 'max_flux_simple': 100, # When to switch to simple SED\n\n # rawSeeing is a bit big, so need this one to get the right size stamp.\n # But others (airmass, band) may be omitted in this case.\n # Also, don't need det_num since not doing vignetting.\n 'rawSeeing': self.opsim_data['rawSeeing'],\n 'image_pos': {\n 'type': 'XY',\n 'x': 0,\n 'y': 0,\n }\n },\n 'image' : {\n 'size': 64,\n 'random_seed': 1234,\n 'wcs': {\n 'type' : 'Tan',\n 'dudx' : 0.2,\n 'dudy' : 0.,\n 'dvdx' : 0.,\n 'dvdy' : 0.2,\n 'ra' : '@input.atm_psf.boresight.ra',\n 'dec' : '@input.atm_psf.boresight.dec',\n },\n 'bandpass': {\n 'file_name': 'LSST_r.dat',\n 'wave_type': 'nm',\n 'thin': 1.e-4,\n },\n 'noise': {'type': 'Poisson'},\n }\n }\n\n # First make a reference image, using photon shooting\n config1 = galsim.config.CopyConfig(config)\n ref_img = galsim.config.BuildImage(config1)\n\n # Repeat with an object bright enough to switch to FFT\n config['gal']['flux'] = 1.e8\n with CaptureLog() as cl:\n img = galsim.config.BuildImage(config, logger=cl.logger)\n #print(cl.output)\n assert 'Check if we should switch to FFT' in cl.output\n assert 'Yes. Use FFT for this object.' in cl.output\n\n print('Peak of reference PSF (flux=1.e5): ',ref_img.array.max())\n print('Peak of FFT PSF (flux=1.e8): ',img.array.max())\n print('FWHM of reference PSF: ',ref_img.view(scale=0.2).calculateFWHM())\n print('FWHM of FFT PSF: ',img.view(scale=0.2).calculateFWHM())\n print('Rmom of reference PSF: ',ref_img.view(scale=0.2).calculateMomentRadius())\n print('Rmom of FFT PSF: ',img.view(scale=0.2).calculateMomentRadius())\n\n # The FFT image is about 10^3 x brighter than the reference image.\n # Scale it down to make it easier to compare to the reference image.\n img /= 1.e3\n\n # Peaks should now be similar\n np.testing.assert_allclose(ref_img.array.max(), img.array.max(), rtol=0.05)\n\n # The sizes should also be pretty close\n np.testing.assert_allclose(ref_img.view(scale=0.2).calculateFWHM(),\n img.view(scale=0.2).calculateFWHM(), rtol=0.05)\n np.testing.assert_allclose(ref_img.view(scale=0.2).calculateMomentRadius(),\n img.view(scale=0.2).calculateMomentRadius(), rtol=0.1)\n\n # Inded the whole image should be similar, but this is pretty noisy,\n # so we need some loose tolerances for this one.\n np.testing.assert_allclose(ref_img.array, img.array, rtol=0.15, atol=50)","def test_sinePSD(self):\n data = _load_mtdata('PASC.dat.gz')\n # Calculate the spectra.\n spec, freq = sine_psd(data, 1.0)\n # No NaNs are supposed to be in the output.\n self.assertEqual(np.isnan(spec).any(), False)\n self.assertEqual(np.isnan(freq).any(), False)\n # Load the good data.\n datafile = os.path.join(os.path.dirname(__file__), 'data',\n 'sine_psd.npz')\n spec2 = np.load(datafile)['spec']\n freq2 = np.arange(43201) * 1.15740741e-05\n # Compare.\n np.testing.assert_almost_equal(freq, freq2)\n np.testing.assert_almost_equal(spec / spec, spec2 / spec, 2)","def inst_bp(instrument,array=\"2\"):\n\n if instrument == \"MUSTANG2\" or instrument == \"MUSTANG\":\n srms = (300*u.um).to(\"m\") # surface RMS (microns)\n ### Reference: https://science.nrao.edu/facilities/gbt/proposing/GBTpg.pdf\n EA90 = 0.36 # Aperture efficiency at 90 GHz\n ### The beam efficiencies should be taken as 1.37* Aperture Efficiency\n R90 = np.exp(-4.0*np.pi*(srms/(const.c/(9.0e10*u.s**-1))).value) #\n Gnot = EA90/R90 # Unphysical, but see documentation...\n if instrument == \"MUSTANG2\":\n flow = 75.0 # GHz\n fhig = 105.0 # GHz\n else:\n flow = 82.5 # GHz\n fhig = 97.5 # GHz\n \n farr = np.arange(flow,fhig,1.0) # frequency array.\n tran = farr*0.0 + 1.0 # Let the transmission be unity everywhere.\n Larr = const.c.value/(farr*1.0e9) # Keep calm and carry on.\n ### Old formula:\n #Ruze = Gnot * np.exp(-4.0*np.pi*(srms.value)/Larr)\n ### Correct formula: (10 April 2018)\n Ruze = Gnot * np.exp(-(4.0*np.pi*srms.value/Larr)**2)\n NRuz = Ruze / np.max(Ruze) # Normalize it\n band = tran * Ruze # Bandpass, with (unnormalized) Ruze efficiency\n \n if instrument == \"NIKA2\" or instrument == \"NIKA\":\n caldir='/home/romero/NIKA2/NIKA_SVN/Processing/Pipeline/Calibration/BP/'\n bpfile=caldir+'Transmission_2017_Jan_NIKA2_v1.fits'\n hdulist = fits.open(bpfile)\n\n if array == \"1H\": # 1mm (260 GHz) array, Horizontal Polarization\n tbdata = hdulist[1].data # 1H\n freq = tbdata.field(0)\n tran = tbdata.field(1)\n erro = tbdata.field(2)\n atmt = tbdata.field(3)\n cfreq1h = np.sum(freq*tran)/np.sum(tran)\n \n if array == \"1V\": # 1mm (260 GHz) array, Vertical Polarization\n tbdata = hdulist[2].data # 1V\n freq = tbdata.field(0)\n tran = tbdata.field(1)\n erro = tbdata.field(2)\n atmt = tbdata.field(3)\n cfreq1v = np.sum(freq*tran)/np.sum(tran)\n \n if array == \"2\": # 2mm (150 GHz) array\n tbdata = hdulist[3].data # 2\n freq = tbdata.field(0)\n tran = tbdata.field(1)\n erro = tbdata.field(2)\n atmt = tbdata.field(3)\n cfreq2 = np.sum(freq*tran)/np.sum(tran)\n\n ### Trim the zero-frequency listing, if any.\n gi=np.where(freq > 0)\n freq = freq[gi]\n tran = tran[gi]\n erro = erro[gi]\n atmt = atmt[gi]\n \n### Calculate Aperture efficiencies from information found at:\n### http://www.iram.es/IRAMES/mainwiki/Iram30mEfficiencies\n Beff = 0.630 # at 210 GHz\n Aeff = Beff/1.27 # See text on webpage\n srms = (66.0*u.um).to(\"m\") # surface RMS (microns)\n R210 = np.exp(-4.0*np.pi*(srms/(const.c/(2.1e11*u.s**-1))).value) #\n Gnot = Aeff/R210 # Unphysical, but see documentation...\n\n Larr = const.c.value/(freq*1.0e9) # Keep calm and carry on. \n Ruze = Gnot * np.exp(-4.0*np.pi*(srms.value)/Larr)\n NRuz = Ruze / np.max(Ruze) # Normalize it\n band = tran * Ruze # Bandpass, with (unnormalized) Ruze efficiency\n farr = freq\n \n#########################################################################\n\n if instrument == 'ACT90':\n srms = (27.0*u.um).to(\"m\") # surface RMS (microns)\n EA90 = 0.95 # I'm making this number up...\n R90 = np.exp(-4.0*np.pi*(srms/(const.c/(9.0e10*u.s**-1))).value) #\n Gnot = EA90/R90 # Unphysical, but see documentation...\n flow = 65.0 # GHz\n fhig = 125.0 # GHz\n farr = np.arange(flow,fhig,1.0) # frequency array.\n freq_ref = 90.0 # I took EA90 to be a fictitious aperature efficiency at 90 GHz\n band = ruze_eff(farr,freq_ref,EA90,srms)\n\n if instrument == 'ACT150':\n srms = (27.0*u.um).to(\"m\") # surface RMS (microns)\n EA90 = 0.95 # I'm making this number up...\n R90 = np.exp(-4.0*np.pi*(srms/(const.c/(9.0e10*u.s**-1))).value) #\n Gnot = EA90/R90 # Unphysical, but see documentation...\n flow = 120.0 # GHz\n fhig = 180.0 # GHz\n farr = np.arange(flow,fhig,1.0) # frequency array.\n freq_ref = 90.0 # I took EA90 to be a fictitious aperature efficiency at 90 GHz\n band = ruze_eff(farr,freq_ref,EA90,srms)\n\n\n return band, farr","def Char_Gate(NV,res ,B_field=400):\n\n\n #data = np.loadtxt(\"NV_Sim_8.dat\") #Placeholder data to test the script\n #NV = np.vstack((data[:,3],data[:,4]))\n #physical constants\n gamma_c = 1.071e3 #g-factor for C13 in Hz/G\n #Model parameters\n omega_larmor = 2*np.pi*gamma_c*B_field\n tau_larmor = 2*np.pi/omega_larmor\n tau = res[0]\n n_pulses = int(res[1]*2) #So that we do a pi -pulse\n\n Ix = 0.5 * np.array([[0,1],[1,0]])\n Iz = 0.5* np.array([[1,0],[0,-1]])\n H0 = (omega_larmor)*Iz\n exH0 =linalg.expm(-1j*H0*tau)\n\n\n M = np.zeros(np.shape(NV)[0])\n for idC in range(np.shape(NV)[0]):\n A= 2*np.pi*NV[idC,0]\n B= 2*np.pi*NV[idC,1] #Converts to radial frequency in Hz/G\n H1 = (A+omega_larmor) *Iz +B*Ix\n exH1 = linalg.expm(-1j*H1*tau)\n V0 = exH0.dot(exH1.dot(exH1.dot(exH0)))\n V1 = exH1.dot(exH0.dot(exH0.dot(exH1)))\n n0 = Calc_axis(V0)\n n1 =Calc_axis(V1)\n phi = np.real(2*np.arccos(np.trace(V0)/2))\n M[idC] = 1 - (1-np.dot(n0,n1))*np.sin(n_pulses * phi /2 )**2\n\n Signal = -M.prod()\n F = (1-(Signal+1)/2)\n return F","def sin(x):\n return 0.0","def _calculate_strehl(self):\n\n self.strehl = np.exp(-1*((2*np.pi/self.science_wavelength)*self.high_order_wfe)**2)","def line_SFR(**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n if p.line == 'CO(2-1)': p.select = 'Zsfr'\n\n GR = glo.global_results(sim_run=p.sim_run,nGal=p.nGal)\n \n marker = 'o'\n if p.sim_run == p.sim_runs[0]: marker = '^'\n\n L_line = getattr(GR,'L_'+p.line+'_sun')#[380:400]#[0:100]\n SFR = getattr(GR,'SFR')#[380:400]#[0:100]\n M_star = getattr(GR,'M_star')#[380:400]#[0:100]\n # G0_mw = getattr(GR,'F_FUV_mw')#[0:100]\n Zsfr = getattr(GR,'Zsfr')#[380:400]#[0:100]\n R_gas = getattr(GR,'R2_gas')#[380:400]#[0:100]\n M_H2 = getattr(GR,'M_H2_R2_gas')#[380:400]#[0:100]\n # if 'CO' in p.line: p.select = 'Sigma_M_H2'\n\n # Take only MS galaxies?\n if p.MS == True:\n indices = aux.select_salim18(GR.M_star,GR.SFR)\n L_line = L_line[indices]\n SFR = SFR[indices]\n M_star = M_star[indices]\n Zsfr = Zsfr[indices]\n R_gas = R_gas[indices]\n M_H2 = M_H2[indices]\n print('With MS selection criteria: only %i galaxies' % (len(L_line)))\n\n # Just selection of galaxies\n #SFR = SFR[0:10]\n #Zsfr = Zsfr[0:10]\n #R_gas = R_gas[0:10]\n #M_H2 = M_H2[0:10]\n #L_line = L_line[0:10]\n #M_star = M_star[0:10]\n\n SFR = SFR[L_line > 0]\n M_star = M_star[L_line > 0]\n Zsfr = Zsfr[L_line > 0]\n R_gas = R_gas[L_line > 0]\n M_H2 = M_H2[L_line > 0]\n L_line = L_line[L_line > 0]\n print('%i data points ' % (len(L_line)))\n\n lSFR = np.log10(SFR)\n lL_line = np.log10(L_line)\n\n\n # plt.plot(np.log10(M_star),np.log10(SFR),'o')\n # s = aseg\n\n labs = {'_100Mpc_M10':'Mach=10 power-law',\\\n '_100Mpc_arepoPDF_CMZ':'SIGAME v3',\\\n '_25Mpc_arepoPDF_M51':'SIGAME v3 (Simba-25)',\\\n '_100Mpc_arepoPDF_M51':'SIGAME v3 (Simba-100)'}\n lab = labs[p.sim_run+p.table_ext]\n\n if p.add:\n ax = p.ax\n else:\n fig,ax = plt.subplots(figsize=(8,6))\n\n if p.select == 'Sigma_M_H2':\n Sigma_M_H2 = M_H2/(np.pi*R_gas**2)/1e6 # per pc^-2\n m = ax.scatter(lSFR[np.argsort(Sigma_M_H2)],lL_line[np.argsort(Sigma_M_H2)],marker=marker,s=14,\\\n c=np.log10(Sigma_M_H2[np.argsort(Sigma_M_H2)]),vmin=-2.5,vmax=2.2,label=lab,alpha=0.5,zorder=10)\n p.vmin = np.log10(Sigma_M_H2.min())\n p.vmax = np.log10(Sigma_M_H2.max())\n if p.cb:\n cbar = plt.colorbar(m,ax=ax)\n cbar.set_label(label=r'log $\\Sigma_{H2}$ [M$_{\\odot}$/pc$^2$]',size=15)\n if p.select == 'M_star':\n m = ax.scatter(lSFR[np.argsort(M_star)],lL_line[np.argsort(M_star)],marker=marker,s=8,\\\n c=np.log10(M_star[np.argsort(M_star)]),vmin=-2.5,vmax=2.2,label=lab,alpha=0.5,zorder=10)\n # Just one galaxy\n # m = ax.scatter(lSFR,lL_line,marker=marker,s=15,\\\n # c=np.log10(Sigma_M_H2),vmin=-2.5,vmax=2.2,label=lab,alpha=1,zorder=10)\n if p.cb:\n cbar = plt.colorbar(m,ax=ax)\n cbar.set_label(label=r'log $M_{star}$ [M$_{\\odot}$]',size=15)\n if p.select == 'Zsfr':\n print('min and max Zsfr in sims: ',Zsfr.min(),Zsfr.max())\n p.vmin = np.log10(0.01)\n p.vmax = np.log10(3)\n m = ax.scatter(lSFR,lL_line,marker=marker,s=20,\\\n c=np.log10(Zsfr),label=lab,alpha=0.6,zorder=10,vmin=p.vmin,vmax=p.vmax)\n if p.cb:\n cbar = plt.colorbar(m,ax=ax)\n cbar.set_label(label=r'log $\\langle Z\\rangle_{\\mathrm{SFR}}$ [Z$_{\\odot}$]',size=15)\n if p.select == 'F_FUV_mw':\n m = ax.scatter(lSFR,lL_line,marker=marker,s=20,\\\n c=np.log10(G0_mw),label=lab,alpha=0.6,zorder=10)\n if p.cb:\n cbar = plt.colorbar(m,ax=ax)\n cbar.set_label(label='log ' + getlabel('G0'),size=15)\n if p.select == 'f_HII':\n f_HII[f_HII == 0] = np.min(f_HII[f_HII > 0])\n m = ax.scatter(lSFR[np.argsort(f_HII)],lL_line[np.argsort(f_HII)],marker=marker,s=20,\\\n c=np.log10(f_HII[np.argsort(f_HII)]),label=lab,alpha=0.6,zorder=10)\n if p.cb:\n cbar = plt.colorbar(m,ax=ax)\n cbar.set_label(label='log HII region fraction',size=15)\n\n\n # Label galaxies?\n # for i in range(len(SFR)):\n # if SFR[i] > 0:\n # ax.text(SFR[i],L_line[i],'G%i' % GR.gal_num[i],fontsize=7)\n\n if p.add_obs:\n if (p.select == 'Zsfr') | (p.select == 'Sigma_M_H2'): \n add_line_SFR_obs(p.line,L_line,ax,select=p.select,vmin=p.vmin,vmax=p.vmax)\n else:\n add_line_SFR_obs(p.line,L_line,ax,select=p.select)\n\n ax.set_xlabel('log ' + getlabel('SFR'))\n ax.set_ylabel('log ' + getlabel(p.line))\n handles,labels = ax.get_legend_handles_labels()\n handles = np.flip(handles)\n labels = np.flip(labels)\n if ('CO' in p.line) | ('[OI]' in p.line): \n ax.legend(handles,labels,loc='upper left',fontsize=7,frameon=True,framealpha=0.5)\n else:\n ax.legend(handles,labels,loc='lower right',fontsize=7,frameon=True,framealpha=0.5)\n if not p.xlim: p.xlim = np.array([-3,4])\n if not p.ylim: \n p.ylim = [np.median(lL_line) - 5,np.median(lL_line) + 3]\n if p.line == '[OI]63': p.ylim = [np.median(lL_line) - 5,np.median(lL_line) + 4]\n if 'CO' in p.line: p.ylim = [np.median(lL_line) - 4,np.median(lL_line) + 4]\n\n ax.set_xlim(p.xlim)\n ax.set_ylim(p.ylim)\n ax.grid(ls='--')\n\n if p.savefig & (not p.add):\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \n plt.savefig(p.d_plot + 'luminosity/%s_SFR.png' % p.line, format='png', dpi=300)","def PCO1S12Noise():\n #Get data\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/' \\\n 'NoiseStudy/TestOptics_PCO1S12/'\n d1,dx1 = met.read4DFits(wdir+'161202_PCO1S12_4InchCut_Avg8_Meas1.fits')\n d2,dx2 = met.read4DFits(wdir+'161202_PCO1S12_4InchCut_Avg8_Meas2.fits')\n d3,dx3 = met.read4DFits(wdir+'161202_PCO1S12_4InchCut_Avg8_Meas3.fits')\n\n #Construct power spectra\n f12,pow12 = fourier.meanPSD((d1-d2)[:,100:-100],\\\n win=np.hanning,dx=dx1,irregular=True)\n f23,pow23 = fourier.meanPSD((d2-d3)[:,100:-100],\\\n win=np.hanning,dx=dx1,irregular=True)\n f13,pow13 = fourier.meanPSD((d1-d3)[:,100:-100],\\\n win=np.hanning,dx=dx1,irregular=True)\n\n #Mid frequency\n midfreq = [1000*np.sqrt(np.sum(p[np.logical_and(f>.1,f<1.)])) \\\n for f,p in zip([f12,f23,f13],[pow12,pow23,pow13])]\n\n #Plot\n plt.loglog(f12,pow12/f12[0],label='1-2: %.2f' % midfreq[0])\n plt.loglog(f23,pow23/f23[0],label='2-3: %.2f' % midfreq[1])\n plt.loglog(f13,pow13/f13[0],label='1-3: %.2f' % midfreq[2])\n plt.legend(loc='lower left')\n plt.grid()\n plt.title('4D Repeatability: PCO1S12')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n\n print midfreq\n\n return f12,pow12","def Fbol_SDSSg(Teff_vec, gmag_vec):\n Teff_vec = np.float64(Teff_vec)\n \n hdulist = fits.open('../Scratchwork/SDSS_filter_curves.fits')\n data = hdulist[2].data\n wvln = data['wavelength'] #ang\n resp = data['respt']\n wvln = wvln/1e4 #microns\n minw, maxw = wvln[0], wvln[-1]\n thru = interp1d(wvln, resp, bounds_error=False, fill_value=0.0)\n \n hc_k = 14388.8 #microns*K\n hc4pi = 4.99 #10^18 J*micron\n rad = 7.57e-16 #10^18 J micron-3 K-4\n def g2bol_ratio(Teff):\n plnk = lambda w: hc4pi / w**5 / (np.exp(hc_k/Teff/w) - 1.0) #J micron-4\n total = rad*Teff**4 #J micron-3\n part = quad(lambda w: plnk(w)*thru(w), minw, maxw)[0]\n return part/total\n #I checked and integrating plnk from 0 to inf gives the same as total\n \n g2bol_vec = np.array(map(g2bol_ratio, Teff_vec))\n FgF0 = 10**(-2.5*gmag_vec) #ratio of flux to a reference flux of mag 0\n FbolF0 = FgF0/g2bol_vec\n return FbolF0","def sin_values(period=360):\n angles = (2 * pi * i / period for i in range(period))\n for a in cycle(angles):\n yield sin(a)","def test_single_ended_ols_wls_estimate_synthetic():\n\n from dtscalibration import DataStore\n import numpy as np\n\n np.random.seed(0)\n\n cable_len = 100.\n nt = 50\n time = np.arange(nt)\n x = np.linspace(0., cable_len, 500)\n ts_cold = np.ones(nt) * 4.\n ts_warm = np.ones(nt) * 20.\n\n C_p = 15246\n C_m = 2400.\n dalpha_r = 0.0005284\n dalpha_m = 0.0004961\n dalpha_p = 0.0005607\n gamma = 482.6\n cold_mask = x < 0.5 * cable_len\n warm_mask = np.invert(cold_mask) # == False\n temp_real = np.ones((len(x), nt))\n temp_real[cold_mask] *= ts_cold + 273.15\n temp_real[warm_mask] *= ts_warm + 273.15\n\n st = C_p * np.exp(-dalpha_r * x[:, None]) * \\\n np.exp(-dalpha_p * x[:, None]) * \\\n np.exp(gamma / temp_real) / (np.exp(gamma / temp_real) - 1)\n ast = C_m * np.exp(-dalpha_r * x[:, None]) * \\\n np.exp(-dalpha_m * x[:, None]) / (np.exp(gamma / temp_real) - 1)\n\n print('alphaint', cable_len * (dalpha_p - dalpha_m))\n print('alpha', dalpha_p - dalpha_m)\n print('C', np.log(C_p / C_m))\n print('x0', x.max())\n\n ds = DataStore({\n 'st': (['x', 'time'], st),\n 'ast': (['x', 'time'], ast),\n 'userAcquisitionTimeFW': (['time'], np.ones(nt)),\n 'cold': (['time'], ts_cold),\n 'warm': (['time'], ts_warm)\n },\n coords={\n 'x': x,\n 'time': time},\n attrs={\n 'isDoubleEnded': '0'})\n\n sections = {\n 'cold': [slice(0., 0.5 * cable_len)],\n 'warm': [slice(0.5 * cable_len, cable_len)]}\n\n # OLS\n ds.calibration_single_ended(sections=sections,\n st_label='st',\n ast_label='ast',\n method='ols',\n solver='sparse')\n\n np.testing.assert_almost_equal(\n ds.gamma.values, gamma, decimal=6)\n np.testing.assert_almost_equal(\n ds.dalpha.values, dalpha_p - dalpha_m, decimal=8)\n np.testing.assert_almost_equal(\n ds.TMPF.values, temp_real - 273.15, decimal=4)\n\n # WLS\n ds.calibration_single_ended(sections=sections,\n st_label='st',\n ast_label='ast',\n st_var=1.,\n ast_var=1.,\n method='wls',\n solver='sparse')\n\n np.testing.assert_almost_equal(\n ds.gamma.values, gamma, decimal=6)\n np.testing.assert_almost_equal(\n ds.dalpha.values, dalpha_p - dalpha_m, decimal=8)\n np.testing.assert_almost_equal(\n ds.TMPF.values, temp_real - 273.15, decimal=4)\n\n pass","def sine_wave_generator(fs, t, spl_value, freq):\r\n\r\n # \"Peak\" value in Pascals (amplitude)\r\n p_ref = 2e-5\r\n pressure_rms = p_ref * (10.00 ** (spl_value / 20.00))\r\n\r\n # Sample range\r\n # samples = np.linspace(0, t, int(fs * t), endpoint=False)\r\n time = np.arange(0, t, 1 / fs)\r\n\r\n # Theta lets you specify the sine wave value at time 0\r\n theta = 0\r\n\r\n # Amplitude of the signal\r\n amplitude = np.sqrt(2) * pressure_rms\r\n\r\n # Signal calculation\r\n signal = np.array(amplitude * np.sin((2.00 * math.pi * freq * time) + theta))\r\n\r\n return signal, time","def sin(obj):\n\tif isinstance(obj, Variable):\n\t\tval = np.sin(obj.val)\n\t\tder = np.cos(obj.val)\n\t\tif len(obj.der.shape)>len(der.shape):\n\t\t\tder = np.expand_dims(der,1)\n\t\tder = np.multiply(der, obj.der)\n\t\treturn Variable(val, der)\n\telse:\n\t\treturn np.sin(obj)","def syntheticSeismogram(d, rho, v, wavf, wavA=1., usingT=True, wavtyp = 'RICKER', dt=0.0001, dmax=200):\n\n v, rho, d = np.array(v, dtype=float), np.array(rho, dtype=float), np.array(d, dtype=float)\n usingT = np.array(usingT, dtype=bool)\n\n _, t = getTimeDepth(d,v,dmax)\n rseries,R = getReflectivity(d,rho,v)\n\n # time for reflectivity series\n tref = t[1:-1]\n\n # create time vector\n t = np.arange(t.min(),t.max(),dt)\n\n # make wavelet\n twav = np.arange(-2.0/np.min(wavf), 2.0/np.min(wavf), dt)\n\n # Get source wavelet\n wav = {'RICKER':getRicker, 'ORMSBY':getOrmsby, 'KLAUDER':getKlauder}[wavtyp](wavf,twav)\n wav = wavA*wav\n\n rseriesconv = np.zeros(len(t))\n for i in range(len(tref)):\n index = np.abs(t - tref[i]).argmin()\n rseriesconv[index] = rseries[i]\n\n # Do the convolution\n seis = np.convolve(wav,rseriesconv)\n tseis = np.min(twav)+dt*np.arange(len(seis))\n index = np.logical_and(tseis >= 0, tseis <= np.max(t))\n tseis = tseis[index]\n seis = seis[index]\n\n return tseis, seis, twav, wav, tref, rseries","def refCylNoise():\n #Get data\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/' \\\n 'NoiseStudy/RefCylinderMeasurements/'\n d1,dx1 = met.read4DFits(wdir+'161205_RefCylinder_Avg8_Meas1.fits')\n d2,dx2 = met.read4DFits(wdir+'161205_RefCylinder_Avg8_Meas2.fits')\n d3,dx3 = met.read4DFits(wdir+'161205_RefCylinder_Avg8_Meas3.fits')\n\n p1,px1 = met.read4DFits(wdir+'161205_RefCylinder_'\n 'ParrotingTestPitch_Meas1.fits')\n p2,px2 = met.read4DFits(wdir+'161205_RefCylinder_'\n 'ParrotingTestPitch_Meas2.fits')\n p3,px3 = met.read4DFits(wdir+'161205_RefCylinder_'\n 'ParrotingTestRoll_Meas1.fits')\n p4,px4 = met.read4DFits(wdir+'161205_RefCylinder_'\n 'ParrotingTestRoll_Meas2.fits')\n\n #Construct baseline power spectra\n f1,pow1 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1)\n f2,pow2 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1,axis=1)\n \n #Construct parroted power spectra\n f3,pow3 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx1)\n f4,pow4 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx2,axis=1)\n f5,pow5 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx1)\n f6,pow6 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx2,axis=1)\n\n #Plot\n plt.loglog(f1,pow1/f1[0],label='Axial Baseline')\n plt.loglog(f2,pow2/f2[0],label='Azimuthal Baseline')\n plt.loglog(f3,pow3/f3[0],label='Pitch Axial')\n plt.loglog(f4,pow4/f4[0],label='Pitch Azimuthal')\n plt.loglog(f5,pow5/f5[0],label='Roll Axial')\n plt.loglog(f6,pow6/f6[0],label='Roll Azimuthal')\n\n return f1,pow1","def schwefel(indiv):\n\ttamanho = len(indiv)\n\n\ty = 418.9829 * tamanho - sum([-x * math.sin(math.sqrt(math.fabs(x))) for x in indiv])\n\treturn y","def __init__(self, n): # this is equivalent to starting a random one\n self.n = n\n # From table S1 in the supplemental materials\n # each c parameters is [body,limb]\n self.cv0 = [0.3, 0.0]\n self.cv1 = [0.2, 0.2]\n self.cR0 = [0.196,0.131]\n self.cR1 = [0.065,0.131]\n #[[dbodylow,dbodyhigh],[dlimblow,dlimbhigh]]\n self.d_params = [[1,5],[1,3]]\n # which oscillators are limb oscillators and which ones are body oscillators is pretty constant\n n_body = n - 4\n self.osc_class = [0 if i < n_body else 1 for i in range(self.n)] # 0 for body oscillator, 1 for limb oscillator\n # list of keys that can be mutated during evolution\n self.evolvables = ['w', 'phi', 'a', 'gsl', 'gsh', 'gb1', 'gb2', 'theta', 'ampl', 'ampl_dot']\n self.scalars = set(['gsl', 'gsh', 'gb1', 'gb2'])\n self.nonzeros = set([int(i) for i in \"8 160 29 181 50 202 71 223 92 244 113 265 134 286 155 307 1 20 22 41 43 62 64 83 85 104 106 125 127 146 169 188 190 209 211 230 232 251 253 272 274 293 295 314 320 321 322 323 364 365 366 367 348 349 350 351 392 393 394 395 338 376 337 356 359 397 379 398\".split(\" \")])\n self.shapes = {'w':n*n,\n 'phi':n*n,\n 'a':n,\n 'theta':n,\n 'ampl':n,\n 'ampl_dot':n}\n self.sizes = {'w':n*n,\n 'phi':n*n,\n 'a':n,\n 'theta':n,\n 'ampl':n,\n 'ampl_dot':n}","def default(N=500, p=5001, f0=(2.5,)):\n #N = N\n #f0=f0\n nsamples = p\n fsample = 400\n\n ripple_db = 40.0\n cutoff_hz = 10.0\n \n harmonics = [Harmonic(1, 0.5, 0), \n Harmonic(0.4, 2.5, pi/2 + 0.1),\n Harmonic(0.2, 15.3, pi/2),\n Harmonic(0.1, 23.45, pi/2 + 0.8)]\n \n t = np.arange(nsamples) / fsample\n signal = np.zeros((N, nsamples))\n for ampl, freq, phase in harmonics:\n ampl = ampl*np.ones(t.shape)\n ampl = np.tile(ampl, (N,1)) + np.outer(0.2*np.random.randint(2, size=(N,)), ampl)\n \n phase = phase*np.ones(t.shape)\n phase = np.tile(phase, (N,1)) + np.outer(0.5*np.random.randint(2, size=(N,)), phase)\n \n x = ampl * np.cos(2*pi*freq*t + phase)\n signal += np.random.normal(0, 0.8*ampl, (N, nsamples)) + x\n \n references = np.zeros((2*len(f0), nsamples))\n for i, fx in enumerate(f0):\n references[2*i,:] = np.cos(2*pi*fx*t)\n references[2*i+1,:] = np.sin(2*pi*fx*t)\n \n nyq_rate = fsample/2.\n width = 5. / nyq_rate\n \n ntaps, beta = kaiserord(ripple_db, width)\n window = firwin(ntaps, cutoff_hz/nyq_rate, window=('kaiser', beta))\n\n return signal, references, window","def one_transition_spectrum_abs(self,tr):\n \n\n ta = tr[\"ta\"] # TimeAxis\n dd = tr[\"dd\"] # transition dipole strength\n om = tr[\"om\"] # frequency - rwa\n gg = tr[\"gg\"] # natural broadening (constant or time dependent)\n fwhm = tr[\"fwhm\"] # Additional gaussian broadening of the spectra\n sgm = fwhm/(2*numpy.sqrt(2*numpy.log(2)))\n \n # CD and fluorescence can be calculated in this step\n # TODO if rotatory strength defined calculate also circular dichroism spectra\n # TOOD calculate fluorescence spectra (for fluorescence there should be a switch because it should be calculated only for the first transition) \n \n \n if self.system._has_system_bath_coupling:\n# ct = tr[\"ct\"] # correlation function\n \n # convert correlation function to lineshape function\n #gt = self._c2g(ta,ct.data)\n gt = tr[\"gt\"]\n # calculate time dependent response\n at = numpy.exp(-gt -1j*om*ta.data)\n else:\n # calculate time dependent response\n at = numpy.exp(-1j*om*ta.data) \n# plt.figure()\n# plt.title(\"Absorption\")\n# plt.plot(ta.data,numpy.real(at))\n# plt.plot(ta.data,numpy.imag(at))\n \n \n if len(gg) == 1:\n gam = gg[0]\n rt = numpy.exp(gam*ta.data)\n at *= rt\n #print(\"Constant: \", rt[20], len(at))\n else:\n rt = numpy.exp((gg)*ta.data) \n at *= rt\n #print(\"Time dependent: len = \", rt[20], len(rt))\n \n if fwhm!=0.0:\n gauss = numpy.exp(-2*(numpy.pi**2)*(sgm**2)*(ta.data**2))\n at *= gauss\n \n # Fourier transform the result\n ft = dd*numpy.fft.hfft(at)*ta.step\n ft = numpy.fft.fftshift(ft)\n # invert the order because hfft is a transform with -i\n ft = numpy.flipud(ft) \n # cut the center of the spectrum\n Nt = ta.length #len(ta.data) \n return ft[Nt//2:Nt+Nt//2]","def SFR_Custom(self, z):\n a = self.customSFR[0] \n b = self.customSFR[1] \n c = self.customSFR[2] \n d = self.customSFR[3] \n SFR = a * ((1+z)**b) / (1 + ((1+z)/c)**d) * 1e9 #[1e9 for GPc-3]\n return SFR # [Msun yr-1 Gpc-3] in comoving volume","def sine(x, period, var):\r\n return var*np.sin((2*np.pi/period)*x)","def BoatEarMoon():\n D=1\n alpha=math.radians(83)\n beta=math.radians(42) \n phi=math.radians(70) \n mu=math.radians(10) \n omega=math.radians(30) \n A=25, a=12, b=20, L=0, P=0, W1=0, W2=0, N=0\n \n resMode()","def sin_transition(freq1, freq2, frames, start_idx=0, samplerate=SAMPLERATE):\n t = (start_idx + np.arange(frames)) / samplerate\n\n trans = (np.sin(np.pi/4*(np.linspace(0,1,frames)-0.5)*4)+1)/2 # store to not recompute each time\n return np.sin(2 * np.pi * (freq1 + (freq2-freq1)*trans) * t).reshape(-1,1)","def sin_transition3(freq1, freq2, frames, start_idx=0, samplerate=SAMPLERATE):\n t = (start_idx + np.arange(frames)) / samplerate\n t = t.reshape(-1, 1)\n return np.sin(2 * np.pi * (freq1*(t[-1]-t)*(t[-1]-t) + freq2*(t-t[0])*(t-t[0]))/(t[-1]-t[0])/(t[-1]-t[0]) * t).reshape(-1,1)","def test_double_ended_two_matching_sections_and_two_asym_atts():\n from dtscalibration import DataStore\n\n cable_len = 100.0\n nt = 5\n time = np.arange(nt)\n nx_per_sec = 4\n nx = nx_per_sec * 9\n x = np.linspace(0.0, cable_len, nx)\n ts_cold = 4.0 + np.cos(time) * 4\n ts_warm = 20.0 + -np.sin(time) * 4\n ts_ground = np.linspace(1, 9, num=nx_per_sec)\n\n C_p = 1324 # 1/2 * E0 * v * K_+/lam_+^4\n eta_pf = np.cos(time) / 10 + 1 # eta_+ (gain factor forward channel)\n eta_pb = np.sin(time) / 10 + 1 # eta_- (gain factor backward channel)\n C_m = 5000.0\n eta_mf = np.cos(time + np.pi / 8) / 10 + 1\n eta_mb = np.sin(time + np.pi / 8) / 10 + 1\n dalpha_r = 0.005284\n dalpha_m = 0.004961\n dalpha_p = 0.005607\n gamma = 482.6\n talph_fw = 0.95\n talph_bw = 0.85\n\n temp_real_kelvin = np.zeros((len(x), nt)) + 273.15\n temp_real_kelvin[:nx_per_sec] += ts_cold[None]\n temp_real_kelvin[nx_per_sec : 2 * nx_per_sec] += ts_warm[None]\n temp_real_kelvin[2 * nx_per_sec : 3 * nx_per_sec] += ts_ground[:, None]\n temp_real_kelvin[3 * nx_per_sec : 4 * nx_per_sec] += ts_ground[::-1, None]\n temp_real_kelvin[5 * nx_per_sec : 6 * nx_per_sec] += ts_ground[:, None] + 5\n temp_real_kelvin[6 * nx_per_sec : 7 * nx_per_sec] += ts_ground[:, None] + 5\n temp_real_kelvin[7 * nx_per_sec : 8 * nx_per_sec] += ts_warm[None]\n temp_real_kelvin[8 * nx_per_sec : 9 * nx_per_sec] += ts_cold[None]\n\n temp_real_celsius = temp_real_kelvin - 273.15\n\n st = (\n eta_pf[None]\n * C_p\n * np.exp(-dalpha_r * x[:, None])\n * np.exp(-dalpha_p * x[:, None])\n * np.exp(gamma / temp_real_kelvin)\n / (np.exp(gamma / temp_real_kelvin) - 1)\n )\n st[3 * nx_per_sec :] *= talph_fw\n st[6 * nx_per_sec :] *= talph_fw\n ast = (\n eta_mf[None]\n * C_m\n * np.exp(-dalpha_r * x[:, None])\n * np.exp(-dalpha_m * x[:, None])\n / (np.exp(gamma / temp_real_kelvin) - 1)\n )\n rst = (\n eta_pb[None]\n * C_p\n * np.exp(-dalpha_r * (-x[:, None] + cable_len))\n * np.exp(-dalpha_p * (-x[:, None] + cable_len))\n * np.exp(gamma / temp_real_kelvin)\n / (np.exp(gamma / temp_real_kelvin) - 1)\n )\n rst[: 3 * nx_per_sec] *= talph_bw\n rst[: 6 * nx_per_sec] *= talph_bw\n rast = (\n eta_mb[None]\n * C_m\n * np.exp(-dalpha_r * (-x[:, None] + cable_len))\n * np.exp(-dalpha_m * (-x[:, None] + cable_len))\n / (np.exp(gamma / temp_real_kelvin) - 1)\n )\n\n ds = DataStore(\n {\n \"TMPR\": ([\"x\", \"time\"], temp_real_celsius),\n \"st\": ([\"x\", \"time\"], st),\n \"ast\": ([\"x\", \"time\"], ast),\n \"rst\": ([\"x\", \"time\"], rst),\n \"rast\": ([\"x\", \"time\"], rast),\n \"userAcquisitionTimeFW\": ([\"time\"], np.ones(nt)),\n \"userAcquisitionTimeBW\": ([\"time\"], np.ones(nt)),\n \"cold\": ([\"time\"], ts_cold),\n \"warm\": ([\"time\"], ts_warm),\n },\n coords={\"x\": x, \"time\": time},\n attrs={\"isDoubleEnded\": \"1\"},\n )\n\n sections = {\n \"cold\": [slice(0.0, x[nx_per_sec - 1])],\n \"warm\": [slice(x[nx_per_sec], x[2 * nx_per_sec - 1])],\n }\n ms = [\n (\n slice(x[2 * nx_per_sec], x[3 * nx_per_sec - 1]),\n slice(x[3 * nx_per_sec], x[4 * nx_per_sec - 1]),\n True,\n ),\n (\n slice(x[5 * nx_per_sec], x[6 * nx_per_sec - 1]),\n slice(x[6 * nx_per_sec], x[7 * nx_per_sec - 1]),\n False,\n ),\n ]\n\n ds.calibration_double_ended(\n sections=sections,\n st_var=0.5,\n ast_var=0.5,\n rst_var=0.1,\n rast_var=0.1,\n method=\"wls\",\n solver=\"sparse\",\n trans_att=[x[3 * nx_per_sec], x[6 * nx_per_sec]],\n matching_sections=ms,\n )\n\n assert_almost_equal_verbose(temp_real_celsius, ds.tmpf.values, decimal=7)\n assert_almost_equal_verbose(temp_real_celsius, ds.tmpb.values, decimal=7)\n assert_almost_equal_verbose(temp_real_celsius, ds.tmpw.values, decimal=7)\n pass","def sinh(ang):\r\n if not isinstance(ang, dec.Decimal):\r\n ang = dec.Decimal(ang)\r\n context = getcontext()\r\n context.prec += 2\r\n num = ang * ang\r\n den = 5\r\n term = ang * num / 6\r\n total = ang + term\r\n while True:\r\n prev = dec.Decimal(term)\r\n term *= num / den / (den - 1)\r\n if term == 0 or term.logb() < total.logb() - context.prec:\r\n context.prec -= 2\r\n return +total\r\n total += term\r\n den += 2","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 aeroFus(F,alpha,beta,rp,V0=50.):\r\n a = alpha * m.pi/180;\r\n S_Cyl = 0.25 * m.pi * F.cD ** 2;\r\n f_F = (F.cL + F.bL + F.nL) / F.cD;\r\n FF = 1. + 2.2/(f_F ** (1.5)) - 0.9/(f_F ** (3.));\r\n gen = F.getGen();\r\n x = np.concatenate([np.linspace(0,gen[17,0],50), np.linspace(gen[17,0],gen[18,0],100),np.linspace(gen[18,0],gen[19,0],100)]);\r\n ReX = V0*x/(1.57e-5);\r\n delta = np.concatenate([[0.],4.92*x[1:50]/(ReX[1:50]**(0.5)),4.92*x[50]/(ReX[50]**(0.5))+0.35*(x[50:]-x[50])/(ReX[50:]**(0.2))]);\r\n rayon = np.interp(x,gen[:,0],gen[:,1])+delta;\r\n S = m.pi * rayon ** 2;\r\n cp_X = (x[1:]+x[:-1])*0.5;\r\n dS = S[1:]-S[:-1];\r\n \r\n CN_lin = np.sin(2.*a) * S[-1];\r\n CX_lin = np.sin(a)**2 * S[-1];\r\n L_lin = CN_lin * np.cos(a) - CX_lin * np.sin(a);\r\n D_lin = CN_lin * np.sin(a) + CX_lin * np.cos(a);\r\n M_lin = -np.sin(2.*a) * np.sum(dS*cp_X);\r\n ReF = V0 * cp_X /(1.57e-5);\r\n CF = np.concatenate([1.328/(ReF[:49]**0.5), 0.0442/(ReF[49:]**(1./6.))]);\r\n dX = x[1:]-x[:-1];\r\n r2 = np.interp(x,gen[:,0],gen[:,1]);\r\n ds = ((r2[1:]-r2[:-1])**2 + dX ** 2) ** (0.5);\r\n rMoy = (r2[1:]+r2[:-1])*0.5;\r\n dSW = 2*m.pi*ds*rMoy;\r\n Frot = np.sum(CF*dSW)*FF;\r\n D_Culot = 0.14*0.25 * m.pi * F.bD**2; # Lecture Aerodynamics 2A : slender body\r\n if F.bL/F.cD < 0.8:\r\n D_con = 1.4*S_Cyl;\r\n else:\r\n D_con = 1.4 * m.exp(-((F.bL/F.cD)-0.8)*3./0.8) * S_Cyl;\r\n D_windscreen = S_Cyl * 2.e-3;\r\n D_par = (Frot+D_Culot + D_con + D_windscreen);\r\n# D_par = (Frot + D_con + D_windscreen);\r\n Cx = 1.2; # Allen ensures that for transversal flow ok if no compressible effect\r\n L_visc = np.sin(a) * np.abs(np.sin(a)) * np.cos(a) * Cx * np.sum(2.*dX*rMoy);\r\n D_visc = np.abs(np.sin(a) ** 3) * Cx * np.sum(2.*dX*rMoy);\r\n M_visc = - Cx * np.abs(np.sin(a)) * np.sin(a) * np.sum(2.*dX*rMoy*cp_X);\r\n \r\n L = L_lin + L_visc - D_par * np.sin(a);\r\n D = D_lin + D_visc + D_par * np.cos(a);\r\n Moment = M_lin + M_visc;\r\n d = ((rp[0] + F.hDist) ** 2 + (rp[2]+F.vDist)**2)**(0.5);\r\n TP = np.arctan2(-(rp[2]+F.vDist),(rp[0]+F.hDist));\r\n M = Moment + d * L * np.cos(TP+a) + d * D * np.sin(TP + a);\r\n \r\n beta *= m.pi/180.;\r\n CN_lin = np.sin(2.*beta) * S[-1];\r\n CX_lin = np.sin(beta)**2 * S[-1];\r\n Y_lin = - CN_lin * np.cos(beta) + CX_lin * np.sin(beta);\r\n D_lin = CN_lin * np.sin(beta) + CX_lin * np.cos(beta);\r\n N_lin = np.sin(2.*beta) * np.sum(dS*cp_X);\r\n Y_visc = - np.sin(beta) * np.abs(np.sin(beta)) * np.cos(beta) * Cx * np.sum(2.*dX*rMoy);\r\n D_visc = np.abs(np.sin(beta) ** 3) * Cx * np.sum(2.*dX*rMoy);\r\n N_visc = Cx * np.abs(np.sin(beta)) * np.sin(beta) * np.sum(2.*dX*rMoy*cp_X);\r\n N = N_lin + N_visc;\r\n Y = Y_lin + Y_visc + D_par * np.sin(beta);\r\n Dt = D_lin + D_visc;\r\n D += Dt;\r\n dv = rp[0] + F.hDist;\r\n dvt = F.bL+F.cL+F.nL - dv;\r\n TPv = np.arctan2(-rp[1],(rp[0]+F.hDist));\r\n N += dv * (Y_lin + Y_visc) * m.cos(TPv - beta) + dv * Dt * m.sin(TPv-beta) + D_par * np.sin(beta) * dvt ;\r\n Y = 0.; \r\n return L,D,M,Y,N","def gen_OSA(self, time_window_ps, center_wavelength_nm, power, \n power_is_epp = False,\n fileloc = 'O:\\\\OFM\\\\Maser\\\\Dual-Comb 100 MHz System\\\\Pump spectrum-Yb-101614.csv',\n log = True, rows = 30): # Yb spectrum\n \n try:\n self.fileloc = fileloc\n \n self.set_time_window_ps(time_window_ps)\n \n self.center_wl = center_wavelength_nm # reference wavelength (nm) \n \n self.w0 = (2. * np.pi * self.c) / self.center_wl # reference angular frequency \n \n self.setup_grids()\n \n if not power_is_epp: \n power = power / self.frep\n \n # Read in OSA data\n osa_data = np.genfromtxt(self.fileloc, delimiter = ',', skiprows = rows) \n \n wavelengths = osa_data[:,0]# (nm)\n wavelengths = self.internal_wl_from_nm(wavelengths)\n \n intensity = osa_data[:,1]# (arb. units)\n\n if log:\n intensity = 10.**(intensity / 10.)\n \n freq_abs = self.c/wavelengths\n freq_abs = np.sort(freq_abs)\n \n self.freq_rel = freq_abs - self.c / self.center_wl\n \n pulse_envelope = interp1d(self.freq_rel, intensity, kind='linear',\n bounds_error = False, fill_value=0)\n \n self.gridded_intensity = pulse_envelope(self.V / (2*np.pi))\n \n # Calculate time domain complex electric field A\n self.A = IFFT_t(self.gridded_intensity)\n # Calculate normalization factor to achieve requested \n # pulse energy\n e_scale = np.sqrt(power / self.calc_epp() )\n self.A = self.A * e_scale\n \n except IOError:\n print ('File not found.')","def twostr_func(wavelength, F_s, solarzenithangle,albedo_dif, \n\t\t\talbedo_dir, temp_ground, w_0, g, tau_n, temp_c):\n\t\n\t########################\n\t###Import useful libraries\n\t########################\n\timport numpy as np\n\timport pdb\n\timport scipy.linalg\n\n\n\n\n\t########################\n\t###Define model parameters\n\t########################\n\t#Properties of the ground\n\temissivity_ground=1.-albedo_dif #emissivity of ground. 1=perfect BB emitter.\n\n\t#Optical depth structure\n\tNlayer=len(tau_n) #number of layers in the atmospheric model.\n\t\n\ttau_c=np.zeros(Nlayer+1)# tau_c[n] is the cumulative optical depth at the upper edge of layer n. So tau_c[0]=0, and tau_c[N] is the maximum possible.\n\tfor n in range(0, Nlayer):\n\t\ttau_c[n+1]=tau_c[n]+tau_n[n] \n\n\t#In the Toon formalism, j=0 corresponds to space, and j=N+1 corresponds to the planet surface.\n\t#These points in wavelength space define the edges of the bins in tau space. \n\t#Other terminology:\n\t#\ttau_c=cumulative optical depth of layers *above* layer n. \n\t#\ttau_n=total optical depth of the layer n\n\t#\ttau=total optical depth at any point within a layer n, hence satisfying 0<tau<tau_n\n\n\tmu_0=np.cos(solarzenithangle) #\"incident direction of solar beam\"\n\n\n\t########################\n\t###Determine the two-stream approximation coefficients.\n\t########################\n\t#Eddington and quadrature are good at solar wavelengths (i.e., not thermal blackbody dominated). delta scalings of Joseph et al (1976) recommended to replace w_0, g, tau in this case. However, when dominated by internal isotropic sources like the Planck function, hemispheric mean approximation is preferable. When w_0=0, quadrature case has problems. This happens esp at thermal wavelengths. Again this favors using hemispheric mean at these wavelengths\n\t\n\t#We use quadrature because 1) we are at solar wavelengths for this UV work and 2) that's what twostr.f does (which is our comparison case)\n\tgamma_1= np.sqrt(3.)*(2.-w_0*(1.+g))/2. #consistent with Toon et al; consistent with Pierrehumbert gamma_1\n\tgamma_2=np.sqrt(3.)*w_0*(1.-g)/2. #consistent with Toon et al; consistent with Pierrehumbert gamma_2\n\tgamma_3=(1.-np.sqrt(3.)*g*mu_0)/2. #consistent with Toon et al; equal to the Pierrehumbert gamma_plus/w_0\n\tgamma_4=1.-gamma_3 #consistent with Toon et al; equal to the Pierrehumbert gamma_minus/w_0\n\tmu_1=1./np.sqrt(3.)+np.zeros(np.shape(gamma_1))#In Toon paper (eqn 18), this is given by: (1.-w_0)/(gamma_1-gamma_2). For the quadrature approximation, it is 1./np.sqrt(3.). Given its use, it seems to relate most closely to gamma_B from Pierrehumbert (see eqs 5.27, 5.30)\n\n\t##Eddington\n\t#gamma_1= (7.-w_0*(4.+3.*g))/4.\n\t#gamma_2=-1.*(1.-w_0*(4.-3.*g))/4.\n\t#gamma_3=(2.-3.*g*mu_0)/4.\n\t#gamma_4=1.-gamma_3 #consistent with Toon et al; equal to the Pierrehumbert gamma_minus/w_0\n\t#mu_1=1./2.+np.zeros(np.shape(gamma_1))#In Toon paper (eqn 18), this is given by: (1.-w_0)/(gamma_1-gamma_2). For the quadrature approximation, it is 1./np.sqrt(3.). Given its use, it seems to relate most closely to gamma_B from Pierrehumbert (see eqs 5.27, 5.30)\n\n\talambda=np.sqrt(np.abs(gamma_1*gamma_1-gamma_2*gamma_2)) #this is the lower-case lambda, from eqn 21 of Toon et al\n\t\t\t\t\t\t\t\t #The absolute value was added based on the code Toon just sent us. This corresponds to his AK(L,J) parameter. But it should not matter since gamma_1>gamma_2 for w_0<1.\n\tclambda=(gamma_1-alambda)/(gamma_2) #this is the upper-case lambda, from eqn 22 of Toon et al\n\n\tEMLT=np.exp(-alambda*tau_n) #this appears to be a prefactor used to facilitate computation of eqn 44 of Toon et al\n\te1=1.+clambda*EMLT\n\te2=1.-clambda*EMLT\n\te3=clambda+EMLT\n\te4=clambda-EMLT\n\n\t########################\n\t###Set up calculation\n\t########################\n\t\"\"\"\n\tThe fundamental equation we are solving is of form:\n\tA_{l}*Y_{l-1}+B_{l}*Y_{l}+D{l+1}=E_{l} (equation 39 of Toon et al)\n\tHere, A_l, B_l, D_l, E_l are quantities we determine, and the Y_l is what we solve for.\n\tHence, we can summarize that we are solving a matrix equation that takes form:\n\tPY=E\n\twhere Y[l]=Y_l\n\t E[l]=E_l\n\t P[l, l-1]=A_l [row, column]\n\t P[l, l]=B_l\n\t P[l, l+1]=D_l\n\t P[i,j]=0 else\n\tToon et al use 1-indexing. Hence n runs from 1 to N, l runs from 1 to 2N, where N is the number of layers, and they have:\n\tY_l=Y_{1n} for l=1,3,5,...2n-1...2N-1\n\tY_l=Y_{2n} for l=2,4,6,...2n...2N\n\n\tHowever, we use Python, which has 0-indexing. Hence *we* choose that n runs from 0 to N-1, l runs from 0 to 2N-1, and:\n\tY_l=Y_{1n} for l=0,2,4...2n...2N-2\n\tY_l=Y_{2n} for l=1,3,5...2n+1...2N-1\n\n\tThe Y_{1n} and Y_{2n} are related to F^+_n and F^-_n via equations 31 and 32 of Toon et al.\n\tThis parametrization has been done to remove exponentials with positive operands (ie ones that could grow large and lead to numerical instabilities) from the matrix.\n\n\tNote: The mapping of this PQ=R to the F+ and F- is unclear because of 1) this parametrization in terms of Y_l (done to eliminate numerical instabilities) and 2)further linear combinations done to convert a pentagiagonal matrix to an even simpler tridiagonal matrix. Hence intuitive checks are hard.\n\t\"\"\"\n\n\t########################\n\t###Set up surface flux\n\t########################\n\tS_sfc=albedo_dir*mu_0*np.exp(-tau_c[-1]/mu_0)*np.pi*F_s+emissivity_ground*np.pi*Planck(temp_ground, wavelength)\n\t#Surface emission. Formed by adding blackbody emission from the ground to the reflected energy from the direct beam. The direct beam's reflected energy is assumed to be purely diffuse. This corresponds to equations 37 and 38 of Toon et al. Note that this does NOT match equation 5.31 of Pierrehumbert because it does not include the reflected diffuse radiation. So, this implicitly assumes the diffuse albedo to be 0. \n\n\t########################\n\t###Set up C-values\n\t########################\n\t#In the reshuffled set of parameters used in this formalism, these seem analagous to the forcing term in Pierrehumbert. All the added radiation is contained in here.\n\n\tdef C_plus(n, tau): #implementation of superposition of eqns 23 and 27 from Toon et al\n\t\tsolarrad_denominator=alambda[n]**2.-1./mu_0**2.\n\t\tsolarrad_prefactor=w_0[n]*F_s*np.pi\n\t\tsolarrad_exponential=np.exp(-1.*(tau_c[n]+tau)/mu_0)\n\t\tsolarrad_factor=((gamma_1[n]-1./mu_0)*gamma_3[n]+gamma_4[n]*gamma_2[n])\n\t\tsolarrad=solarrad_prefactor*solarrad_factor*solarrad_exponential/solarrad_denominator #units of flux: erg/s/cm2/nm\n\t\t\n\t\tblackbody_prefactor=2*np.pi*mu_1[n]\n\t\tB0n=Planck(temp_c[n], wavelength)\n\t\tB1n=(Planck(temp_c[n+1], wavelength)-B0n)/tau_n[n] #this is effectively a slope\n\t\tblackbody_factor=B0n+B1n*(tau+1./(gamma_1[n]+gamma_2[n]))\n\t\tblackbody=blackbody_prefactor*blackbody_factor #start with units of the Planck function, which are: erg/s/cm2/nm/sr. But multiplying by 2pi sr restores the units of flux. So can safely add them. \n\t\t\n\t\tresult=solarrad+blackbody\n\t\treturn result\n\n\tdef C_minus(n, tau): #implementation of superposition of eqns 24 and 27 from Toon et al\n\t\tsolarrad_denominator=alambda[n]**2.-1./mu_0**2.\n\t\tsolarrad_prefactor=w_0[n]*F_s*np.pi\n\t\tsolarrad_exponential=np.exp(-1.*(tau_c[n]+tau)/mu_0)\n\t\tsolarrad_factor=((gamma_1[n]+1./mu_0)*gamma_4[n]+gamma_3[n]*gamma_2[n])\n\t\tsolarrad=solarrad_prefactor*solarrad_factor*solarrad_exponential/solarrad_denominator #units of flux: erg/s/cm2/nm\n\t\t\n\t\tblackbody_prefactor=2*np.pi*mu_1[n]\n\t\tB0n=Planck(temp_c[n], wavelength)\n\t\tB1n=(Planck(temp_c[n+1], wavelength)-B0n)/tau_n[n] #this is effectively a slope\n\t\tblackbody_factor=B0n+B1n*(tau-1./(gamma_1[n]+gamma_2[n]))\n\t\tblackbody=blackbody_prefactor*blackbody_factor #start with units of the Planck function, which are: erg/s/cm2/nm/sr. But multiplying by 2pi sr restores the units of flux. So can safely add them. \n\t\t\n\t\tresult=solarrad+blackbody\n\t\treturn result\n\n\t########################\n\t###Calculate matrix coefficients\n\t#########################\n\t#initialize the A, B, D, and E.\n\tA=np.zeros(Nlayer*2)\n\tB=np.zeros(np.shape(A))\n\tD=np.zeros(np.shape(A))\n\tE=np.zeros(np.shape(A))\n\n\n\t#For l=0 (n=0) we have the boundary condition that the downward diffuse flux at the top of the first layer is equal to any incident diffuse downward flux. We set this to be zero.\n\tA[0]=0.\n\tB[0]=e1[0]\n\tD[0]=-1.*e2[0]\n\tE[0]=0.-1*C_minus(0,0) #This is really F_minus[0,0], i.e. we are assuming there is no downward diffuse flux from the top of the atmosphere.\n\n\t#for l=2N-1 (n=N-1), we have the boundary condition that the upward flux at the surface is the sume of the reflected downward diffuse flux and energy from any other sources (e.g. reflected direct beam, BB emission of the ground)/np.sqrt(3.)\n\tA[2*Nlayer-1]=e1[Nlayer-1]-albedo_dif*e3[Nlayer-1]\n\tB[2*Nlayer-1]=e2[Nlayer-1]-albedo_dif*e4[Nlayer-1]\n\tD[2*Nlayer-1]=0.\n\tE[2*Nlayer-1]=S_sfc-C_plus(Nlayer-1, tau_n[Nlayer-1])+albedo_dif*C_minus(Nlayer-1, tau_n[Nlayer-1])\n\n\t#There is a problem in the Toon paper. As written, the l=2n depends on e_n+1, running over the array edge. twostr.f resolves this by adopting a different mapping: their definition reduces to defining l=2(n+1) and running n from 0 to N-1. In this case, l=2 (The third value in the list of ls) depends on n=0 and n=1. This eliminates the overflow problem. We have implemented this below.\n\t\n\t##For n=1,2,3...N-1, l=2,4,6,...2N-2:\n\tfor n in range(0, Nlayer-1):\n\t\tl=2*(n+1)\n\t\tA[l]=e2[n]*e3[n]-e4[n]*e1[n]\n\t\tB[l]=e1[n]*e1[n+1]-e3[n]*e3[n+1]\n\t\tD[l]=e3[n]*e4[n+1]-e1[n]*e2[n+1]\n\t\t\n\t\tE[l]=e3[n]*(C_plus(n+1, 0.)-C_plus(n, tau_n[n]))+e1[n]*(C_minus(n,tau_n[n])-C_minus(n+1,0.))\n\n\n\t#For n=0...N-2, l=1,3...2N-3:\n\tfor n in range(0, Nlayer-1):\n\t\tl=2*n+1\n\t\tA[l]=e2[n+1]*e1[n]-e3[n]*e4[n+1]\n\t\tB[l]=e2[n]*e2[n+1]-e4[n]*e4[n+1]\n\t\tD[l]=e1[n+1]*e4[n+1]-e2[n+1]*e3[n+1]\n\t\t\n\t\tE[l]=e2[n+1]*(C_plus(n+1, 0.)-C_plus(n, tau_n[n]))-e4[n+1]*(C_minus(n+1, 0)-C_minus(n, tau_n[n])) #twostr.f has a -1*e_{4,n+1}. We have applied the same even though this is NOT what is written in the Toon et al paper. We have done this because Toon told us (6/26/2015) that there are some sign errors in the coefficients, and we currently trust the validated CLIMA code over the paper we know has errors in it. EDIT: Looking at the code Toon shared with us, he does the same. \n\n\n\t########################\n\t###Assemble matrix equation components\n\t#########################\n\tP=np.zeros([Nlayer*2,Nlayer*2])\n\n\t#l=0: no \"A\" coefficient b/c l-1 has no meaning\n\tP[0,0]=B[0]\n\tP[0,1]=D[0]\n\n\t#l=2N-1: no \"D\" coefficient b/c l+1 has no meaning\n\tP[2*Nlayer-1,2*Nlayer-1-1]=A[2*Nlayer-1]\n\tP[2*Nlayer-1,2*Nlayer-1]=B[2*Nlayer-1]\n\n\tfor l in range(1, Nlayer*2-1): #This populates the matrix P in PY=E. \n\t\tP[l, l-1]=A[l]\n\t\tP[l,l]=B[l]\n\t\tP[l,l+1]=D[l]\n\n\t########################\n\t###Invert matrix\n\t#########################\n\t#Y=np.linalg.solve(P, E) #this is the Y_l\n\t\n\t#try using a specialized solver\n\tab=np.zeros([3,2*Nlayer])\n\tab[0,:]=np.append(0.0, np.diag(P, k=1))\n\tab[1,:]=np.diag(P, k=0)\n\tab[2,:]=np.append(np.diag(P, k=-1),0.0)\n\t#pdb.set_trace()\n\tY=scipy.linalg.solve_banded((1,1), ab, E) #this is the Y_l\n\n\n\t########################\n\t###Convert from Y_l to Y_1n, Y_2n\n\t#########################\n\t#The Y_1n as defined in Toon et al correspond to l=1,3, 5...2N-1. Adjusting for the zero-indexing of Python as we have done, they instead correspond to l=0,2,...2N-2\n\t#The Y_2n as defined in Toon et al correspond to l=2,4,6...2N. Adjusting for Python zero-indexing as we have done, they instead correspond to l=1,3,5...2N-1.\n\t#For detail, see eq. 40.\n\tY_1=np.zeros(Nlayer)\n\tY_2=np.zeros(Nlayer)\n\tfor n in range(0, Nlayer):\n\t\tY_1[n]=Y[2*n]\n\t\tY_2[n]=Y[2*n+1] \n\t\t#last number called is Nlayer-1=N-1, so is consistent.\n\t\n\t########################\n\t###Convert from Y_1n, Y_2n to F_plus, F_minus\n\t#########################\n\tdef F_plus(n,tau): #defined from Eqn 31 of Toon et al.\n\t\tterm1=Y_1[n]*(np.exp(-alambda[n]*(tau_n[n]-tau))+clambda[n]*np.exp(-alambda[n]*tau))\n\t\tterm2=Y_2[n]*(np.exp(-alambda[n]*(tau_n[n]-tau))-clambda[n]*np.exp(-alambda[n]*tau))\n\t\tterm3=C_plus(n,tau)\n\t\t\n\t\tresult=term1+term2+term3\n\t\treturn result\n\n\tdef F_minus(n, tau): #defined from Eqn 32 of Toon et al.\n\t\tterm1=Y_1[n]*(clambda[n]*np.exp(-alambda[n]*(tau_n[n]-tau))+np.exp(-alambda[n]*tau))\n\t\tterm2=Y_2[n]*(clambda[n]*np.exp(-alambda[n]*(tau_n[n]-tau))-np.exp(-alambda[n]*tau))\n\t\tterm3=C_minus(n,tau)\n\t\t\n\t\tresult=term1+term2+term3\n\t\treturn result\n\t\n\t########################\n\t###Evaluate F_plus, F_minus at boundary edges\n\t#########################\n\tF_plus_tau0=np.zeros(np.shape(tau_n))\n\tF_plus_taumax=np.zeros(np.shape(tau_n))\n\tF_minus_tau0=np.zeros(np.shape(tau_n))\n\tF_minus_taumax=np.zeros(np.shape(tau_n))\n\n\tfor n in range(0, Nlayer):\n\t\tF_plus_tau0[n]=F_plus(n, 0.)\n\t\tF_plus_taumax[n]=F_plus(n, tau_n[n])\n\t\tF_minus_tau0[n]=F_minus(n, 0.)\n\t\tF_minus_taumax[n]=F_minus(n, tau_n[n])\n\n\n\t########################\n\t###Convert from Y_1n, Y_2n to F_net, mean intensity.\n\t#########################\n\t#test if diffuse flux dominates over direct flux. If direct flux dominant, instead set mu_1=mu_0\n\t\n\t#if F_minus_taumax[-1]<mu_0*np.pi*F_s*np.exp(-tau_c[-1]/mu_0):\n\t\t#mu_1=np.zeros(np.shape(mu_1))+mu_0\n\t#mu_1=np.zeros(np.shape(mu_1))+mu_0\n\t\n\tF_net=np.zeros(np.shape(tau_n)) #defined from Eqn 48 of Toon et al. This quantity is the net flux at the BASE of layer n.\n\tfor n in range(0, Nlayer):\n\t\tdirect=mu_0*np.pi*F_s*np.exp(-(tau_c[n]+tau_n[n])/mu_0) #eqn 50 of Toon et al\n\n\t\tterm1=Y_1[n]*(e1[n]-e3[n])\n\t\tterm2=Y_2[n]*(e2[n]-e4[n])\n\t\tterm3=C_plus(n, tau_n[n])-C_minus(n, tau_n[n])\n\t\t\n\t\tF_net[n]=term1+term2+term3 -direct\n\n\tAMEAN=np.zeros(np.shape(tau_n)) #defined from Eqn 49 of Toon et al. This is the equivalent of the quantity AMEAN in the twostr.f code. It is equal to 4*np.pi*J_n, where J_n is the mean intensity at the base of layer n. Hence this quantity AMEAN should be equal to the total intensity received by a point at the base of layer n. \n\tfor n in range(0, Nlayer):\n\t\tdirect=mu_0*np.pi*F_s*np.exp(-(tau_c[n]+tau_n[n])/mu_0) #eqn 50 of Toon et al\n\t\n\t\tterm1=Y_1[n]*(e1[n]+e3[n])\n\t\tterm2=Y_2[n]*(e2[n]+e4[n])\n\t\tterm3=C_plus(n, tau_n[n])+C_minus(n, tau_n[n])\n\t\t\n\t\t#AMEAN[n]=(1./mu_1[n])*(term1+term2+term3)+direct/mu_0\t\n\t\tAMEAN[n]=(1./mu_1[n])*(F_plus_taumax[n]+F_minus_taumax[n])+direct/mu_0\t\n\t\n\t########################\n\t###Compute \"surface intensity\"\n\t#########################\t\n\t#\"Surface intensity\" refers to the total intensity that would be intercepted by a particle at the surface of the planet. Whereas the total intensity is equal to (F_plus[-1]+F_minus[-1])/mu_1+direct[-1]/mu_0, the surface intensity is instead equal to (F_minus[-1])/mu_1+direct[-1]/mu_0, i.e. the downwelling diffuse intensity (since the bottom intensity is cut out due to there being a planet there) plus the direct intensity\n\t\n\tsurface_intensity=(F_minus_taumax[-1]/mu_1[-1])+(np.pi*F_s)*np.exp(-(tau_c[-1])/mu_0)\n\t\n\t########################\n\t###Return Result\n\t#########################\n\t#F_minus_tau0\n\t#np.max(np.abs((F_minus_taumax[:-1]-F_minus_tau0[1:]))/F_minus_tau0[1:])\n\t#np.max(np.abs((F_plus_taumax[:-1]-F_plus_tau0[1:]))/F_plus_tau0[1:])\n\t\n\treturn (F_plus_tau0, F_plus_taumax, F_minus_tau0, F_minus_taumax, F_net, AMEAN, surface_intensity)","def sin(x):\r\n # see decorator for function body\r","def fnutofwave(warr, farr):\n c= 2.99792458e18 #spped of light in Angstroms/s\n return farr*c/warr**2","def sine(\n self, cycles=1, period=1.0, peak=0.5, transient=1, skew_ratio=sb.NotSpecified, **kwargs\n ):\n if skew_ratio is sb.NotSpecified:\n skew_ratio = peak\n return dict(\n waveform=Waveform.SINE,\n cycles=cycles,\n skew_ratio=skew_ratio,\n transient=transient,\n period=period,\n )","def test_sinusoidal_invalid_freq_shape():\n with pytest.raises(ValueError):\n d = data.Sinusoidal(input_dim=3, output_dim=7, freq=np.zeros([5, 9]))","def trig_conditions(tr):\n \n\n \n ##############\n #TRACE RELATED\n ##############\n avg_tr = np.average(tr)\n \n shifted_tr = tr - avg_tr \n \n abs_tr = abs(shifted_tr)\n \n sort_tr = np.sort(abs_tr)\n \n tr_99 = sort_tr[int(0.999*len(sort_tr))]\n\n #95% noise to signal area ratio calculation\n area_big = tr_99 * int(0.95*len(sort_tr))\n \n area_small = np.sum(sort_tr[:int(0.95*len(sort_tr))])\n \n \n area_condition = area_small / area_big; print area_condition\n \n # if signal is quite noisy, use recursive STALTA, else use classic STALTA\n \n df = tr.stats.sampling_rate\n \n \n if area_condition <= 0.1:\n \n print(\"CLEAN SIGNAL!\\n\")\n\n ctf = abs(1-carlSTATrig(tr.data, int(5 * df), int(10 * df), 0.0001, 0.0001))\n \n sort_ctf = np.sort(ctf)\n \n ctf_low = sort_ctf[int(0.80*len(sort_ctf))]\n \n ctf_99 = sort_ctf[int(0.999*len(sort_ctf))]\n \n max_trig = ctf_99\n \n trig_on = ctf_low + 0.4 * (max_trig - ctf_low)\n\n trig_off = 0.8 * trig_on\n \n if not max_trig > 1.25 * ctf_low:\n trig_on = 0; trig_off = 0;\n \n \n \n elif 0.1 < area_condition < 0.16:\n \n print(\"NOISY SIGNAL!\\n\")\n\n ctf = abs(1-recSTALTA(tr.data, int(5 * df), int(10 * df)))\n \n sort_ctf = np.sort(ctf)\n \n ctf_low = sort_ctf[int(0.90*len(sort_ctf))]\n \n ctf_99 = sort_ctf[int(0.999*len(sort_ctf))]\n \n max_trig = ctf_99\n \n trig_on = ctf_low + 0.4 * (max_trig - ctf_low)\n\n trig_off = 0.8 * trig_on\n \n if not max_trig > 1.25 * ctf_low:\n trig_on = 0; trig_off = 0;\n \n else:\n print(\"TRACE TOO NOISY TO DETECT SIGNAL!\")\n trig_on = 0; trig_off = 0;\n ctf = abs(1-recSTALTA(tr.data, int(5 * df), int(10 * df)))\n\n \n\n\n\n \n\n \n \n ############\n #ctf RELATED\n ############\n\n \n #set conditional for noise. This is MINIMUM threshold.\n #ctf_avg = np.average(ctf)\n #ctf_mode = scipy.stats.mode(ctf)\n #ctf_std = np.std(ctf)\n \n\n \n \n #plt.figure()\n #plt.plot(sort_ctf)\n #plt.show()\n\n \n\n \n \n \n return trig_on, trig_off, ctf","def _get_cyclical_sin(df: pd.Series, col_name: str, col_type: str, col_max: Any):\n return np.sin(2. * np.pi * df[\"{}_{}\".format(col_name, col_type)] / col_max)","def sine(x, period=10.0, start_phase=0.0, name=''):\n x = x.astype(np.float)\n variables = {\n 'function': sine, 'period': period, 'start_phase': start_phase}\n y = np.sin(2*np.pi*(x / period) + start_phase)\n return packer(x, y, variables, name=name)","def set_frequency(self):\r\n def move_synth(delta_f_synth):\r\n sign_delta_f_synth = int(delta_f_synth/abs(delta_f_synth))\r\n stepsize_Hz = int(10)\r\n num_steps = int(abs(delta_f_synth)/stepsize_Hz)\r\n remainder_Hz = round(abs(delta_f_synth)%stepsize_Hz,1)\r\n self.synth.set_incr(stepsize_Hz, 'Hz')\r\n for nn in range(num_steps): # slowly move the synth by delta_f_synth in stepsize steps\r\n self.synth.walk(sign_delta_f_synth)\r\n time.sleep(0.1)\r\n self.synth.set_incr(remainder_Hz, 'Hz')\r\n self.synth.walk(sign_delta_f_synth)\r\n time.sleep(0.1)\r\n \r\n def get_delta_f_synth():\r\n #get latest f_rep,f_0\r\n self.get_frequency() \r\n #calculate required f_rep to get desired PA_freq. switches n and frep in above eq.\r\n f_rep_goal = (self.setfrequency - self.sign_lock * self.f_lock - self.sign_0 * self.f_0) / self.n\r\n # print 'f_rep_goal = %.0f Hz'%f_rep_goal\r\n # lock uses 3rd harmonic so synth must be set to *3\r\n delta_f_synth = (f_rep_goal - self.f_rep)*3 \r\n delta_f_synth = round(delta_f_synth,1)\r\n # print 'delta_f_synth = %.1f Hz'%delta_f_synth\r\n return delta_f_synth\r\n \r\n iteration = 0\r\n delta_f_synth = get_delta_f_synth()\r\n while abs(delta_f_synth) > self.synth_tol:\r\n move_synth(delta_f_synth)\r\n delta_f_synth = get_delta_f_synth()\r\n iteration += 1\r\n if iteration > self.max_iteration:\r\n # print 'REACHED MAX ITERATION: delta_f_synth = %.1f'%delta_f_synth\r\n break","def test_filtfilt_filter_sinusoid(self):\n T = 1.0\n samples = 1000\n\n waveform_k0 = get_sinusoid(frequency=5, sample_rate=samples // T, dtype=self.dtype, device=self.device).squeeze(\n 0\n )\n waveform_k1 = get_sinusoid(\n frequency=200,\n sample_rate=samples // T,\n dtype=self.dtype,\n device=self.device,\n ).squeeze(0)\n waveform = waveform_k0 + waveform_k1\n\n # Transfer function numerator and denominator polynomial coefficients\n # corresponding to 8th-order Butterworth filter with 100-cycle/T cutoff.\n # Generated with\n # >>> from scipy import signal\n # >>> b_coeffs, a_coeffs = signal.butter(8, 0.2)\n b_coeffs = torch.tensor(\n [\n 2.39596441e-05,\n 1.91677153e-04,\n 6.70870035e-04,\n 1.34174007e-03,\n 1.67717509e-03,\n 1.34174007e-03,\n 6.70870035e-04,\n 1.91677153e-04,\n 2.39596441e-05,\n ],\n dtype=self.dtype,\n device=self.device,\n )\n a_coeffs = torch.tensor(\n [\n 1.0,\n -4.78451489,\n 10.44504107,\n -13.45771989,\n 11.12933104,\n -6.0252604,\n 2.0792738,\n -0.41721716,\n 0.0372001,\n ],\n dtype=self.dtype,\n device=self.device,\n )\n\n # Extend waveform in each direction, preserving periodicity.\n padded_waveform = torch.cat((waveform[:-1], waveform, waveform[1:]))\n\n output_waveform = F.filtfilt(padded_waveform, a_coeffs, b_coeffs)\n\n # Remove padding from output waveform; confirm that result\n # closely matches waveform_k0.\n self.assertEqual(\n output_waveform[samples - 1 : 2 * samples - 1],\n waveform_k0,\n atol=1e-3,\n rtol=1e-3,\n )","def sin_profile(N,N_cut,rising=False):\n if rising:\n sin_apo = np.zeros(N)\n for i in range(int(N)):\n if i>=N_cut:\n sin_apo[i] = 1-(-1.0/(2.0*np.pi)*np.sin(2.0*np.pi*(N-i)/float(N-N_cut))+(N-i)/float(N-N_cut))\n else:\n sin_apo = np.ones(int(N))\n for i in range(int(N)):\n if i>=N_cut:\n sin_apo[i] = (-1.0/(2.0*np.pi)*np.sin(2.0*np.pi*(N-i)/float(N-N_cut))+(N-i)/float(N-N_cut))\n return sin_apo","def warm_region_cal(audio_samples, fs):\n #window the audio\n windowed_samples = timbral_util.window_audio(audio_samples)\n\n # need to define a function for the roughness stimuli, emphasising the 20 - 40 region (of the bark scale)\n min_bark_band = 10\n max_bark_band = 40\n mean_bark_band = (min_bark_band + max_bark_band) / 2.0\n array = np.arange(min_bark_band, max_bark_band)\n x = timbral_util.normal_dist(array, theta=0.01, mean=mean_bark_band)\n x -= np.min(x)\n x /= np.max(x)\n\n wr_array = np.zeros(240)\n wr_array[min_bark_band:max_bark_band] = x\n\n # need to define a second array emphasising the 20 - 40 region (of the bark scale)\n min_bark_band = 80\n max_bark_band = 240\n mean_bark_band = (min_bark_band + max_bark_band) / 2.0\n array = np.arange(min_bark_band, max_bark_band)\n x = timbral_util.normal_dist(array, theta=0.01, mean=mean_bark_band)\n x -= np.min(x)\n x /= np.max(x)\n\n hf_array = np.zeros(240)\n hf_array[min_bark_band:max_bark_band] = x\n\n windowed_loud_spec = []\n windowed_rms = []\n\n wr_vals = []\n hf_vals = []\n\n for i in range(windowed_samples.shape[0]):\n samples = windowed_samples[i, :]\n N_entire, N_single = timbral_util.specific_loudness(samples, Pref=100.0, fs=fs, Mod=0)\n\n # append the loudness spec\n windowed_loud_spec.append(N_single)\n windowed_rms.append(np.sqrt(np.mean(samples * samples)))\n\n wr_vals.append(np.sum(wr_array * N_single))\n hf_vals.append(np.sum(hf_array * N_single))\n\n mean_wr = np.mean(wr_vals)\n mean_hf = np.mean(hf_vals)\n weighted_wr = np.average(wr_vals, weights=windowed_rms)\n weighted_hf = np.average(hf_vals, weights=windowed_rms)\n\n return mean_wr, weighted_wr, mean_hf, weighted_hf","def sin_transition2(freq1, freq2, frames, start_idx=0, samplerate=SAMPLERATE):\n t = (start_idx + np.arange(frames)) / samplerate\n t = t.reshape(-1, 1)\n return np.sin(2 * np.pi * (freq1*(t[-1]-t) + freq2*(t-t[0]))/(t[-1]-t[0]) * t).reshape(-1,1)"],"string":"[\n \"def sim_any_sinmode(gls_obj, in_freq, times):\\n k = np.where(np.round(gls_obj.freq, 5) == in_freq)[0]\\n if len(k) > 1:\\n k = k[0]\\n amp = np.sqrt(gls_obj._a[k]**2 + gls_obj._b[k]**2)\\n ph = np.arctan2(gls_obj._a[k], gls_obj._b[k]) / (2. * np.pi)\\n T0 = times.min() - ph / in_freq\\n offset = gls_obj._off[k] + gls_obj._Y\\n return amp * np.sin(2 * np.pi * in_freq * (times - T0)) + offset\",\n \"def FourierSinusoids(F,w,Fs,synthesis=None):\\n if synthesis==None:\\n synthesis=0;\\n \\n Ts=1.0/Fs; \\n xs=numpy.arange(0,1,Ts) \\n \\n signal=numpy.zeros(np.shape(xs));\\n for i in range(len(F)):\\n omega=2*np.pi*F[i];\\n signal = signal+ w[i]*numpy.cos(-omega*xs);\\n #plot the time domain signal \\n subplot(2,1,1)\\n plt.plot(range(0,len(signal)),signal)\\n xlabel('Time')\\n ylabel('Amplitude')\\n title('time doman')\\n \\n #compute the fourier series coefficient\\n r1=FourierSeries(signal)\\n a1=cabs(r1)\\n \\n if synthesis==0:\\n #plot the freuency domain signal\\n L=len(a1);\\n fr=np.arange(0,L);\\n subplot(2,1,2)\\n plt.stem(fr,a1,'r') # plotting the spectrum\\n xlabel('Freq (Hz)')\\n ylabel('|Y(freq)|')\\n title('complete signal')\\n ticks=np.arange(0,L+1,25);\\n plt.xticks(ticks,ticks); \\n show() \\n \\n if synthesis==1:\\n rsignal=IFourierSeries(r1);\\n print np.allclose(rsignal, signal) \\n subplot(2,1,2) \\n plt.stem(xs,signal)\\n xlabel('Time')\\n ylabel('Amplitude')\\n title('reconstructed signal')\\n show()\",\n \"def sin_custom(f,T,a=0,b=0):\\n fs=44100\\n t=np.linspace(0,T,T*fs)\\n A=np.floor(a*fs*T)\\n D=np.floor(b*fs*T)\\n S1=np.linspace(0,1,A)\\n S2=np.ones(T*fs-A-D)\\n S3=np.linspace(1,0,D)\\n S0=np.sin(2*np.pi*f*t) \\n return(np.hstack((S1,S2,S3))*S0)\",\n \"def SFSchmidt10(jd,mag,errmag,nbin=0.1,bmin=5,bmax=2000):\\n\\n dtarray, dmagarray, sigmaarray = SFarray(jd,mag,errmag)\\n ndt=np.where((dtarray<=365))\\n dtarray=dtarray[ndt]\\n dmagarray=dmagarray[ndt]\\n sigmaarray=sigmaarray[ndt]\\n\\n bins=bincalc(nbin,bmin,bmax)\\n #print(len(bins))\\n\\n\\n sf_list=[]\\n tau_list=[]\\n numobj_list=[]\\n\\n for i in range(0,len(bins)-1):\\n n=np.where((dtarray>=bins[i]) & (dtarray<bins[i+1]))\\n nobjbin=len(n[0])\\n if nobjbin>=6:\\n dmag1=np.abs(dmagarray[n])\\n derr1=np.sqrt(sigmaarray[n])\\n sf=(np.sqrt(np.pi/2.0)*dmag1-derr1)\\n sff=np.mean(sf)\\n sf_list.append(sff)\\n numobj_list.append(nobjbin)\\n #central tau for the bin\\n tau_list.append((bins[i]+bins[i+1])*0.5)\\n\\n\\n SF=np.array(sf_list)\\n nob=np.array(numobj_list)\\n tau=np.array(tau_list)\\n nn=np.where(nob>6)\\n tau=tau[nn]\\n SF=SF[nn]\\n\\n\\n return (tau/365.,SF)\",\n \"def signal_spectral(signal, FS):\\n # check inputs\\n if signal is None or signal == []:\\n print(\\\"Signal is empty.\\\")\\n\\n # ensure numpy\\n signal = np.array(signal)\\n # f, spectrum = st.welch_spectrum(signal, sampling_rate=FS)\\n spectrum = np.fft.fft(signal, FS)[:len(signal)//2]\\n f = np.fft.fftfreq(len(signal))[:len(signal)//2]\\n\\n cum_ff = np.cumsum(spectrum)\\n spect_diff = np.diff(spectrum)\\n #energy, _ = st.signal_energy(spectrum, f)[:]\\n\\n args, names = [], []\\n\\n if dict['spectral_maxpeaks']['use'] == 'yes':\\n # spectral_maxpeaks\\n try:\\n spectral_maxpeaks = np.sum([1 for nd in range(len(spect_diff[:-1])) if (spect_diff[nd+1]<0 and spect_diff[nd]>0)])\\n except:\\n spectral_maxpeaks = None\\n args += [spectral_maxpeaks]\\n names += ['spectral_maxpeaks']\\n\\n # if dict['spect_var']['use'] == 'yes':\\n # # spect_variation\\n # try:\\n # spect_var = np.convolve(energy)\\n # spect_var /= np.max(np.abs(spect_var))\\n # except:\\n # spect_var = None\\n # args += [spect_var]\\n # names += ['spect_var']\\n\\n if dict['curve_distance']['use'] == 'yes':\\n # curve_distance\\n try:\\n curve_distance = np.sum(np.linspace(0, cum_ff[-1], len(cum_ff)) - cum_ff)\\n except:\\n curve_distance = None\\n args += [curve_distance]\\n names += ['curve_distance']\\n\\n if dict['spectral_roll_off']['use'] == 'yes':\\n # spectral_roll_off\\n try:\\n spectral_roll_off = spectral_roll(f, spectrum, cum_ff, 0.95)[0]\\n except:\\n spectral_roll_off = None\\n args += [spectral_roll_off]\\n names += ['spectral_roll_off']\\n\\n if dict['spectral_roll_on']['use'] == 'yes':\\n # spectral_roll_on\\n try:\\n spectral_roll_on = spectral_roll(f, spectrum, cum_ff, 0.05)[0]\\n except:\\n spectral_roll_on = None\\n args += [spectral_roll_on]\\n names += ['spectral_roll_on']\\n\\n if dict['spectral_dec']['use'] == 'yes':\\n # spectral_decrease\\n try:\\n spectral_dec = (1/np.sum(spectrum)) * np.sum((spectrum[:] - spectrum[1])/np.linspace(1, len(spectrum), len(spectrum),1))\\n except:\\n spectral_dec = None\\n args += [spectral_dec]\\n names += ['spectral_dec']\\n\\n if dict['spectral_slope']['use'] == 'yes':\\n # spectral_slope\\n sum_f = np.sum(f)\\n len_f = len(f)\\n try:\\n spectral_slope = (len_f * np.dot(f, spectrum) - sum_f * np.sum(spectrum)) / (len_f * np.dot(f, f) - sum_f ** 2)\\n except:\\n spectral_slope = None\\n args += [spectral_slope]\\n names += ['spectral_slope']\\n\\n sum_spectrum = np.sum(spectrum)\\n norm_spectrum = spectrum / sum_spectrum\\n # spectral_centroid\\n try:\\n spectral_centroid = np.dot(f, norm_spectrum)\\n except:\\n spectral_centroid = None\\n\\n # spectral_spread\\n try:\\n spectral_spread = np.dot(((f - spectral_centroid) ** 2), norm_spectrum)\\n except:\\n spectral_spread = None\\n\\n if dict['spectral_spread']['use'] == 'yes':\\n args += [spectral_spread]\\n names += ['spectral_spread']\\n\\n if dict['spectral_kurtosis']['use'] == 'yes':\\n # spectral_kurtosis\\n try:\\n spectral_kurtosis = np.sum(((f - spectral_centroid) ** 4) * norm_spectrum) / (spectral_spread**2)\\n except:\\n spectral_kurtosis = None\\n args += [spectral_kurtosis]\\n names += ['spectral_kurtosis']\\n\\n if dict['spectral_skewness']['use'] == 'yes':\\n # spectral_skewness\\n try:\\n spectral_skewness = np.sum(((f - spectral_centroid) ** 3) * norm_spectrum) / (spectral_spread ** (3 / 2))\\n except:\\n spectral_skewness = None\\n args += [spectral_skewness]\\n names += ['spectral_skewness']\\n\\n if dict['max_frequency']['use'] == 'yes':\\n # max_frequency\\n try:\\n max_frequency = f[np.where(cum_ff > cum_ff[-1]*0.95)[0][0]]\\n except:\\n max_frequency = None\\n args += [max_frequency]\\n names += ['max_frequency']\\n\\n if dict['fundamental_frequency']['use'] == 'yes':\\n # fundamental_frequency\\n try:\\n fundamental_frequency = f[np.where(cum_ff > cum_ff[-1]*0.5)[0][0]]\\n except:\\n fundamental_frequency = None\\n args += [fundamental_frequency]\\n names += ['fundamental_frequency']\\n\\n # if dict['max_power_spectrum']['use'] == 'yes':\\n # # max_power_spectrum\\n # try:\\n # max_power_spectrum = np.max(spectrum)\\n # except:\\n # max_power_spectrum = None\\n # args += max_power_spectrum\\n # names += 'max_power_spectrum'\\n\\n # if dict['mean_power_spectrum']['use'] == 'yes':\\n # # mean_power_spectrum\\n # try:\\n # mean_power_spectrum = np.mean(spectrum)\\n # except:\\n # mean_power_spectrum = None\\n # args += mean_power_spectrum\\n # names += 'mean_power_spectrum'\\n #\\n # if dict['spectral_skewness']['use'] == 'yes':\\n # try:\\n # spectral_skewness = np.mean(spectrum)\\n # except:\\n # spectral_skewness = None\\n # args += spectral_skewness\\n # names += 'spectral_skewness'\\n #\\n # if dict['spectral_kurtosis']['use'] == 'yes':\\n # try:\\n # spectral_kurtosis = np.mean(spectrum)\\n # except:\\n # spectral_kurtosis = None\\n # args += spectral_kurtosis\\n # names += 'spectral_kurtosis'\\n\\n # if dict['spectral_hist_']['use'] == 'yes':\\n # # histogram\\n # try:\\n # _hist = list(np.histogram(spectrum, bins=int(np.sqrt(len(spectrum))), density=True)[0])\\n # except:\\n # if len(signal) > 1:\\n # _hist = [None] * int(np.sqrt(len(signal)))\\n # else:\\n # _hist = [None]\\n # args += [i for i in _hist]\\n # names += ['spectral_hist_' + str(i) for i in range(len(_hist))]\\n\\n #return utils.ReturnTuple(tuple(args), tuple(names))\\n return args, names\",\n \"def generate_singlesine(time = 0, samples_nb = 1000, rep_frequency = 10 , pulse_frequency = 50, amplitude = 1 , edge = 1, phase_offset = 0, noise = 0):\\r\\n\\r\\n\\tif edge not in [0,1]:\\r\\n\\t\\tprint(colorama.Back.RED + colorama.Style.BRIGHT + \\\"ERROR: invalid phase (either 0 for a rising or a 1 for a falling edge) , exit.\\\"+ colorama.Style.NORMAL + colorama.Back.RESET)\\r\\n\\t\\t# Return code for error (empty input file):\\r\\n\\t\\tsys.exit(10)\\r\\n\\r\\n\\r\\n\\t#Creating empty lists for t and y\\r\\n\\tt = np.zeros(samples_nb)\\r\\n\\r\\n\\tif noise == 0:\\r\\n\\t\\ty = np.zeros(samples_nb)\\r\\n\\telse:\\r\\n\\t\\ty = np.random.normal(0, noise, samples_nb)\\r\\n\\r\\n\\t#Determining the interval limits of t\\r\\n\\tt_limit =1/float(rep_frequency*2)\\r\\n\\r\\n\\t#Updating the t interval\\r\\n\\tt = np.arange(-samples_nb/2,samples_nb/2)/float(samples_nb*rep_frequency) + 1/float(samples_nb*rep_frequency)\\r\\n\\r\\n\\r\\n\\t#calculating the time_shift\\r\\n\\t#delta_t = phase_offset/(2*np.pi*pulse_frequency)\\r\\n\\tdelta_t = phase_offset/(2*np.pi*rep_frequency)\\r\\n\\r\\n\\t#Setting the pulse amplitude\\r\\n\\ta_pulse = amplitude\\r\\n\\tif edge == 1:\\r\\n\\t\\ta_pulse *= -1\\r\\n\\r\\n\\t#Calculating the pulse limits\\r\\n\\tp_limit = 1/float(2*pulse_frequency)\\r\\n\\tp_interval = list ([-p_limit,p_limit])\\r\\n\\r\\n\\r\\n\\tfor n in range (0,len(t)) :\\r\\n\\t\\tif (t[n] + delta_t) > p_interval[0] and (t[n] + delta_t) <= p_interval[1]:\\r\\n\\t\\t\\ty[n] += a_pulse * np.sin(2*np.pi*pulse_frequency*(t[n]+delta_t))\\r\\n\\r\\n\\r\\n\\r\\n\\t#plt.plot(t,y)\\r\\n\\t#plt.show()\\r\\n\\r\\n\\tresult = {}\\r\\n\\tresult ['time'] = time\\r\\n\\tresult ['t'] = t\\r\\n\\tresult ['y'] = y\\r\\n\\r\\n\\treturn result\",\n \"def fluxes(wavelength, s, line, lowlow= 14, lowhigh=6, highlow=6, highhigh = 14, lmin=0, lmax=0, fmin=0, fmax=0, \\n broad=2.355, plot=True, verbose=True, plot_sus = False, fcal = True, fit_continuum = True, median_kernel=35, warnings = True ): # Broad is FWHM for Gaussian sigma= 1,\\n # s must be an array, no a list\\n try: \\n index_maximo_del_rango = s.tolist().index(np.nanmax(s))\\n #print \\\" is AN ARRAY\\\"\\n except Exception:\\n #print \\\" s is A LIST -> must be converted into an ARRAY\\\" \\n s = np.array(s)\\n \\n # Setup wavelength limits\\n if lmin == 0 :\\n lmin = line-65. # By default, +-65 A with respect to line\\n if lmax == 0 :\\n lmax = line+65.\\n \\n # Extract subrange to fit\\n w_spec = []\\n f_spec = []\\n w_spec.extend((wavelength[i]) for i in range(len(wavelength)) if (wavelength[i] > lmin and wavelength[i] < lmax) ) \\n f_spec.extend((s[i]) for i in range(len(wavelength)) if (wavelength[i] > lmin and wavelength[i] < lmax) ) \\n \\n if np.isnan(np.nanmedian(f_spec)): \\n # The data are NAN!! Nothing to do\\n if verbose or warnings: print(\\\" There is no valid data in the wavelength range [{},{}] !!\\\".format(lmin,lmax))\\n \\n resultado = [0, line, 0, 0, 0, 0, 0, 0, 0, 0, 0, s ] \\n\\n return resultado\\n \\n else: \\n \\n ## 20 Sep 2020\\n f_spec_m=signal.medfilt(f_spec,median_kernel) # median_kernel = 35 default\\n \\n \\n # Remove nans\\n median_value = np.nanmedian(f_spec)\\n f_spec = [median_value if np.isnan(x) else x for x in f_spec] \\n \\n \\n # Setup min and max flux values in subrange to fit\\n if fmin == 0 :\\n fmin = np.nanmin(f_spec) \\n if fmax == 0 :\\n fmax = np.nanmax(f_spec) \\n \\n # We have to find some \\\"guess numbers\\\" for the Gaussian. Now guess_centre is line\\n guess_centre = line\\n \\n # Define continuum regions: [-lowlow, -lowhigh] and [highlow,highhigh] in Angstroms with respect to guess_centre\\n \\n w_cont=[]\\n f_cont=[]\\n w_cont.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-lowlow and w_spec[i] < guess_centre-lowhigh) or (w_spec[i] > guess_centre+highlow and w_spec[i] < guess_centre+highhigh) ) \\n f_cont.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-lowlow and w_spec[i] < guess_centre-lowhigh) or (w_spec[i] > guess_centre+highlow and w_spec[i] < guess_centre+highhigh) ) \\n \\n if fit_continuum:\\n # Linear Fit to continuum \\n f_cont_filtered=sig.medfilt(f_cont,np.int(median_kernel))\\n #print line #f_cont\\n # if line == 8465.0:\\n # print w_cont\\n # print f_cont_filtered\\n # plt.plot(w_cont,f_cont_filtered)\\n # plt.show()\\n # plt.close()\\n # warnings=True\\n try: \\n mm,bb = np.polyfit(w_cont, f_cont_filtered, 1)\\n except Exception:\\n bb = np.nanmedian(f_cont_filtered)\\n mm = 0.\\n if warnings: \\n print(\\\" WARNING: Impossible to get the continuum!\\\")\\n print(\\\" Scaling the continuum to the median value b = \\\",bb,\\\": cont = 0 * w_spec + \\\", bb)\\n continuum = mm*np.array(w_spec)+bb \\n c_cont = mm*np.array(w_cont)+bb \\n \\n else: \\n # Median value in each continuum range # NEW 15 Sep 2019\\n w_cont_low = []\\n f_cont_low = []\\n w_cont_low.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-lowlow and w_spec[i] < guess_centre-lowhigh) ) \\n f_cont_low.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-lowlow and w_spec[i] < guess_centre-lowhigh) ) \\n median_w_cont_low = np.nanmedian(w_cont_low)\\n median_f_cont_low = np.nanmedian(f_cont_low)\\n w_cont_high = []\\n f_cont_high = []\\n w_cont_high.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre+highlow and w_spec[i] < guess_centre+highhigh) ) \\n f_cont_high.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre+highlow and w_spec[i] < guess_centre+highhigh) ) \\n median_w_cont_high = np.nanmedian(w_cont_high)\\n median_f_cont_high = np.nanmedian(f_cont_high) \\n \\n b = (median_f_cont_low-median_f_cont_high)/(median_w_cont_low-median_w_cont_high)\\n a = median_f_cont_low- b * median_w_cont_low\\n \\n continuum = a + b*np.array(w_spec)\\n c_cont = a + b*np.array(w_cont) \\n \\n \\n # rms continuum\\n rms_cont = np.nansum([ np.abs(f_cont[i] - c_cont[i]) for i in range(len(w_cont)) ]) / len(c_cont)\\n \\n # Search for index here w_spec(index) closest to line\\n min_w = np.abs(np.array(w_spec)-line)\\n mini = np.nanmin(min_w)\\n # guess_peak = f_spec[min_w.tolist().index(mini)] # WE HAVE TO SUSTRACT CONTINUUM!!!\\n guess_peak = f_spec[min_w.tolist().index(mini)] - continuum[min_w.tolist().index(mini)]\\n \\n # LOW limit\\n low_limit=0\\n w_fit = []\\n f_fit = []\\n w_fit.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-15 and w_spec[i] < guess_centre)) \\n f_fit.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-15 and w_spec[i] < guess_centre)) \\n if fit_continuum: \\n c_fit=mm*np.array(w_fit)+bb \\n else: \\n c_fit=b*np.array(w_fit)+a \\n \\n fs=[]\\n ws=[]\\n for ii in range(len(w_fit)-1,1,-1):\\n if f_fit[ii]/c_fit[ii] < 1.05 and f_fit[ii-1]/c_fit[ii-1] < 1.05 and low_limit == 0: low_limit = w_fit[ii]\\n # if f_fit[ii]/c_fit[ii] < 1.05 and low_limit == 0: low_limit = w_fit[ii]\\n fs.append(f_fit[ii]/c_fit[ii])\\n ws.append(w_fit[ii])\\n if low_limit == 0: \\n sorted_by_flux=np.argsort(fs)\\n try:\\n low_limit = ws[sorted_by_flux[0]]\\n except Exception:\\n plot=True\\n low_limit = 0\\n \\n # HIGH LIMIT \\n high_limit=0\\n w_fit = []\\n f_fit = []\\n w_fit.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre and w_spec[i] < guess_centre+15)) \\n f_fit.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre and w_spec[i] < guess_centre+15)) \\n if fit_continuum: \\n c_fit=mm*np.array(w_fit)+bb \\n else: \\n c_fit=b*np.array(w_fit)+a\\n \\n fs=[]\\n ws=[]\\n for ii in range(len(w_fit)-1):\\n if f_fit[ii]/c_fit[ii] < 1.05 and f_fit[ii+1]/c_fit[ii+1] < 1.05 and high_limit == 0: high_limit = w_fit[ii]\\n # if f_fit[ii]/c_fit[ii] < 1.05 and high_limit == 0: high_limit = w_fit[ii]\\n fs.append(f_fit[ii]/c_fit[ii])\\n ws.append(w_fit[ii])\\n if high_limit == 0: \\n sorted_by_flux=np.argsort(fs)\\n try:\\n high_limit = ws[sorted_by_flux[0]] \\n except Exception:\\n plot=True\\n high_limit = 0 \\n \\n # Guess centre will be the highest value in the range defined by [low_limit,high_limit]\\n \\n try: \\n rango = np.where((high_limit >= wavelength ) & (low_limit <= wavelength)) \\n index_maximo_del_rango = s.tolist().index(np.nanmax(s[rango]))\\n guess_centre = wavelength[index_maximo_del_rango]\\n except Exception:\\n guess_centre = line #### It was 0 before\\n \\n \\n # Fit a Gaussian to data - continuum \\n p0 = [guess_centre, guess_peak, broad/2.355] # broad is the Gaussian sigma, 1.0 for emission lines\\n try:\\n fit, pcov = curve_fit(gauss, w_spec, f_spec-continuum, p0=p0, maxfev=10000) # If this fails, increase maxfev...\\n fit_error = np.sqrt(np.diag(pcov))\\n \\n # New 28th Feb 2019: Check central value between low_limit and high_limit\\n # Better: between guess_centre - broad, guess_centre + broad\\n # If not, redo fit fixing central value to the peak (it does not work... just fix FWHM= (high_limit-low_limit)/2.5 )\\n \\n if verbose != False: print(\\\" ----------------------------------------------------------------------------------------\\\")\\n # if low_limit < fit[0] < high_limit:\\n if fit[0] < guess_centre - broad or fit[0] > guess_centre + broad:\\n # if verbose: print \\\" Fitted center wavelength\\\", fit[0],\\\"is NOT in the range [\\\",low_limit,\\\",\\\",high_limit,\\\"]\\\"\\n if verbose: print(\\\" Fitted center wavelength\\\", fit[0],\\\"is NOT in the expected range [\\\",guess_centre - broad,\\\",\\\",guess_centre + broad,\\\"]\\\")\\n \\n # print \\\"Re-do fitting fixing center wavelength\\\"\\n # p01 = [guess_peak, broad]\\n # fit1, pcov1 = curve_fit(gauss_fix_x0, w_spec, f_spec-continuum, p0=p01, maxfev=100000) # If this fails, increase maxfev...\\n # fit_error1 = np.sqrt(np.diag(pcov1))\\n # fit[0]=guess_centre\\n # fit_error[0] = 0.\\n # fit[1] = fit1[0]\\n # fit_error[1] = fit_error1[0]\\n # fit[2] = fit1[1]\\n # fit_error[2] = fit_error1[1] \\n \\n fit[0]=guess_centre\\n fit_error[0] = 0.000001\\n fit[1]=guess_peak\\n fit_error[1] = 0.000001\\n fit[2] = broad/2.355\\n fit_error[2] = 0.000001 \\n else:\\n if verbose: print(\\\" Fitted center wavelength\\\", fit[0],\\\"IS in the expected range [\\\",guess_centre - broad,\\\",\\\",guess_centre + broad,\\\"]\\\")\\n \\n \\n if verbose: print(\\\" Fit parameters = \\\", fit[0], fit[1], fit[2])\\n if fit[2] == broad and warnings == True : \\n print(\\\" WARNING: Fit in\\\",fit[0],\\\"failed! Using given centre wavelength (cw), peak at (cv) & sigma = broad/2.355 given.\\\") \\n gaussian_fit = gauss(w_spec, fit[0], fit[1], fit[2])\\n \\n \\n # Estimate rms of the Gaussian fit in range [low_limit, high_limit]\\n residuals = f_spec-gaussian_fit-continuum\\n rms_fit = np.nansum([ ((residuals[i]**2)/(len(residuals)-2))**0.5 for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \\n \\n # Fluxes, FWHM and Eq. Width calculations\\n gaussian_flux = gauss_flux(fit[1],fit[2])\\n error1 = np.abs(gauss_flux(fit[1]+fit_error[1],fit[2]) - gaussian_flux)\\n error2 = np.abs(gauss_flux(fit[1],fit[2]+fit_error[2]) - gaussian_flux)\\n gaussian_flux_error = 1 / ( 1/error1**2 + 1/error2**2 )**0.5\\n \\n \\n fwhm=fit[2]*2.355\\n fwhm_error = fit_error[2] *2.355\\n fwhm_vel = fwhm / fit[0] * C \\n fwhm_vel_error = fwhm_error / fit[0] * C \\n \\n gaussian_ew = gaussian_flux/np.nanmedian(f_cont)\\n gaussian_ew_error = gaussian_ew * gaussian_flux_error/gaussian_flux \\n \\n # Integrated flux\\n # IRAF: flux = sum ((I(i)-C(i)) * (w(i2) - w(i1)) / (i2 - i2) \\n flux = np.nansum([ (f_spec[i]-continuum[i])*(w_spec[i+1]-w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \\n flux_error = rms_cont * (high_limit - low_limit)\\n wave_resolution = (wavelength[-1]-wavelength[0])/len(wavelength)\\n ew = wave_resolution * np.nansum ([ (1 - f_spec[i]/continuum[i]) for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \\n ew_error = np.abs(ew*flux_error/flux) \\n gauss_to_integrated = gaussian_flux/flux * 100.\\n \\n index=0\\n s_s=np.zeros_like(s)\\n for wave in range(len(wavelength)):\\n s_s[wave]=s[wave]\\n if wavelength[wave] == w_spec[0] : \\n s_s[wave] = f_spec[0]-gaussian_fit[0]\\n index=1\\n if wavelength[wave] > w_spec[0] and wavelength[wave] <= w_spec[-1]:\\n s_s[wave] = f_spec[index]-gaussian_fit[index]\\n index=index+1\\n \\n # Plotting \\n ptitle = 'Fit: x0=%.2f y0=%.2e sigma=%.2f flux=%.2e rms=%.3e' % (fit[0], fit[1], fit[2], gaussian_flux, rms_fit)\\n if plot :\\n plt.figure(figsize=(10, 4))\\n # Plot input spectrum\\n plt.plot(np.array(w_spec),np.array(f_spec), \\\"b\\\", lw=3, alpha = 0.8)\\n # Plot median input spectrum\\n plt.plot(np.array(w_spec),np.array(f_spec_m), \\\"orange\\\", lw=3, alpha = 0.5) # 2021: era \\\"g\\\"\\n # Plot spectrum - gauss subtracted\\n plt.plot(wavelength,s_s,\\\"g\\\",lw=3, alpha = 0.6)\\n \\n plt.minorticks_on() \\n plt.xlabel(\\\"Wavelength [$\\\\mathrm{\\\\AA}$ ]\\\")\\n if fcal:\\n plt.ylabel(\\\"Flux [ erg cm$^{-2}$ s$^{-1}$ $\\\\mathrm{\\\\AA}^{-1}$ ]\\\")\\n else:\\n plt.ylabel(\\\"Flux [ counts ]\\\")\\n plt.xlim(lmin,lmax)\\n plt.ylim(fmin,fmax)\\n \\n # Vertical line at guess_centre\\n plt.axvline(x=guess_centre, color='r', linestyle='-', alpha=0.3)\\n # Horizontal line at y = 0\\n plt.axhline(y=0, color='k', linestyle=':', alpha=0.5) \\n # Dashed green regions for continuum, defined by [lowlow, lowhigh] and [highlow,highhigh]\\n plt.axvspan(guess_centre+highlow, guess_centre+highhigh, facecolor='g', alpha=0.15,zorder=3)\\n plt.axvspan(guess_centre-lowlow, guess_centre-lowhigh, facecolor='g', alpha=0.15,zorder=3)\\n # Plot linear fit for continuum\\n plt.plot(w_spec, continuum,\\\"g--\\\")\\n # Plot Gaussian fit \\n plt.plot(w_spec, gaussian_fit+continuum, 'r-', alpha=0.8) \\n # Vertical line at Gaussian center\\n plt.axvline(x=fit[0], color='k', linestyle='-', alpha=0.5)\\n # Vertical lines to emission line\\n plt.axvline(x= low_limit, color='k', linestyle=':', alpha=0.5)\\n plt.axvline(x= high_limit, color='k', linestyle=':', alpha=0.5) \\n # Plot residuals\\n plt.plot(w_spec, residuals, 'k')\\n plt.title(ptitle)\\n plt.show()\\n \\n # Printing results\\n if verbose :\\n print(\\\"\\\\n - Gauss and continuum fitting + integrated flux calculations:\\\\n\\\")\\n print(\\\" rms continuum = %.3e erg/cm/s/A \\\" % (rms_cont)) \\n print(\\\" Gaussian Fit parameters: x0 = ( %.2f +- %.2f ) A \\\" % (fit[0], fit_error[0]))\\n print(\\\" y0 = ( %.3f +- %.3f ) 1E-16 erg/cm2/s/A\\\" % (fit[1]/1E-16, fit_error[1]/1E-16 ))\\n print(\\\" sigma = ( %.3f +- %.3f ) A\\\" % (fit[2], fit_error[2])) \\n print(\\\" rms fit = %.3e erg/cm2/s/A\\\" % (rms_fit))\\n print(\\\" Gaussian Flux = ( %.2f +- %.2f ) 1E-16 erg/s/cm2 (error = %.1f per cent)\\\" % (gaussian_flux/1E-16, gaussian_flux_error/1E-16, gaussian_flux_error/gaussian_flux*100))\\n print(\\\" FWHM = ( %.3f +- %.3f ) A = ( %.1f +- %.1f ) km/s \\\" % (fwhm, fwhm_error, fwhm_vel, fwhm_vel_error))\\n print(\\\" Eq. Width = ( %.1f +- %.1f ) A\\\" % (-gaussian_ew, gaussian_ew_error)) \\n print(\\\"\\\\n Integrated flux = ( %.2f +- %.2f ) 1E-16 erg/s/cm2 (error = %.1f per cent) \\\" % ( flux/1E-16, flux_error/1E-16, flux_error/flux *100)) \\n print(\\\" Eq. Width = ( %.1f +- %.1f ) A\\\" % (ew, ew_error))\\n print(\\\" Gauss/Integrated = %.2f per cent \\\" % gauss_to_integrated)\\n \\n \\n # Plot independent figure with substraction if requested \\n if plot_sus: plot_plot(wavelength,[s,s_s], xmin=lmin, xmax=lmax, ymin=fmin, ymax=fmax, fcal=fcal, frameon=True, ptitle=ptitle)\\n \\n # 0 1 2 3 4 5 6 7 8 9 10 11\\n resultado = [rms_cont, fit[0], fit_error[0], gaussian_flux, gaussian_flux_error, fwhm, fwhm_error, flux, flux_error, ew, ew_error, s_s ]\\n return resultado \\n except Exception:\\n if verbose: \\n print(\\\" - Gaussian fit failed!\\\")\\n print(\\\" However, we can compute the integrated flux and the equivalent width:\\\")\\n \\n flux = np.nansum([ (f_spec[i]-continuum[i])*(w_spec[i+1]-w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \\n flux_error = rms_cont * (high_limit - low_limit)\\n wave_resolution = (wavelength[-1]-wavelength[0])/len(wavelength)\\n ew = wave_resolution * np.nansum ([ (1 - f_spec[i]/continuum[i]) for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \\n ew_error = np.abs(ew*flux_error/flux) \\n \\n if verbose:\\n print(\\\" Integrated flux = ( %.2f +- %.2f ) 1E-16 erg/s/cm2 (error = %.1f per cent) \\\" % ( flux/1E-16, flux_error/1E-16, flux_error/flux *100)) \\n print(\\\" Eq. Width = ( %.1f +- %.1f ) A\\\" % (ew, ew_error))\\n \\n resultado = [0, guess_centre, 0, 0, 0, 0, 0, flux, flux_error, ew, ew_error, s ] # guess_centre was identified at maximum value in the [low_limit,high_limit] range but Gaussian fit failed\\n \\n \\n # Plotting \\n if plot :\\n plt.figure(figsize=(10, 4))\\n plt.plot(np.array(w_spec),np.array(f_spec), \\\"b\\\", lw=3, alpha = 0.5)\\n plt.minorticks_on() \\n plt.xlabel(\\\"Wavelength [$\\\\mathrm{\\\\AA}$]\\\")\\n if fcal:\\n plt.ylabel(\\\"Flux [ erg cm$^{-2}$ s$^{-1}$ $\\\\mathrm{\\\\AA}^{-1}$ ]\\\")\\n else:\\n plt.ylabel(\\\"Flux [ counts ]\\\") \\n plt.xlim(lmin,lmax)\\n plt.ylim(fmin,fmax)\\n \\n # Vertical line at guess_centre\\n plt.axvline(x=guess_centre, color='r', linestyle='-', alpha=0.5)\\n # Horizontal line at y = 0\\n plt.axhline(y=0, color='k', linestyle=':', alpha=0.5) \\n # Dashed green regions for continuum, defined by [lowlow, lowhigh] and [highlow,highhigh]\\n plt.axvspan(guess_centre+highlow, guess_centre+highhigh, facecolor='g', alpha=0.15,zorder=3)\\n plt.axvspan(guess_centre-lowlow, guess_centre-lowhigh, facecolor='g', alpha=0.15,zorder=3)\\n # Plot linear fit for continuum\\n plt.plot(w_spec, continuum,\\\"g--\\\")\\n # Plot Gaussian fit \\n # plt.plot(w_spec, gaussian_fit+continuum, 'r-', alpha=0.8) \\n # Vertical line at Gaussian center\\n # plt.axvline(x=fit[0], color='k', linestyle='-', alpha=0.5)\\n # Vertical lines to emission line\\n plt.axvline(x= low_limit, color='k', linestyle=':', alpha=0.5)\\n plt.axvline(x= high_limit, color='k', linestyle=':', alpha=0.5) \\n # Plot residuals\\n # plt.plot(w_spec, residuals, 'k')\\n plt.title(\\\"No Gaussian fit obtained...\\\")\\n plt.show()\\n \\n \\n return resultado\",\n \"def test_baseline_sinusoidal(self, b0, x0, a, freq):\\n x = np.linspace(-1, 1, 100)\\n y = a * np.cos(2 * np.pi * freq * (x - x0)) + b0\\n\\n b0_guess = guess.constant_sinusoidal_offset(y)\\n\\n self.assertAlmostEqual(b0, b0_guess, delta=0.1)\",\n \"def f_sin(k):\\n return k * k * k * pk(k, suppression)\",\n \"def __generate_sin(self, phase_shift=0):\\n amp = self.SIGNAL_AMPLITUDE / 2\\n fs = self.sampling_freq\\n duration = self.DURATION\\n f = self.pinger_freq\\n b = self.BIAS\\n return (amp * np.sin(2 * np.pi * np.arange(fs * duration) * f / fs +\\n phase_shift) + b).astype(np.float32)\",\n \"def freqdomain(self):\\n \\n\\n #self.df = self.f[1] - self.f[0]\\n #frequency vector\\n #fv = fftshift(fftfreq(len(eta),1./fs))\\n #fv = fv[len(fv)/2:]\\n \\n #spectral analysis\\n self.sn1 = self.espec1(self.n1)\\n self.sn2 = self.espec1(self.n2)\\n self.sn3 = self.espec1(self.n3)\\n self.sn12 = self.espec2(self.n1,self.n2)\\n self.sn13 = self.espec2(self.n1,self.n3)\\n self.sn23 = self.espec2(self.n2,self.n3)\\n \\n #delta freq\\n self.df = self.f[3] - self.f[2]\\n\\n #calculo do numero de onda\\n #self.wavenumber()\\n #k = numeronda(h,f,len(f))\\n #k = np.array(k)\\n\\n #calculo dos coeficientes de fourier - NDBC 96_01 e Steele (1992)\\n c = self.sn2[:,1] + self.sn3[:,1]\\n cc = np.sqrt(self.sn1[:,1] * (c))\\n \\n self.a1 = self.sn12[:,3] / cc\\n self.b1 = self.sn13[:,3] / cc\\n \\n self.a2 = (self.sn2[:,1] - self.sn3[:,1]) / c\\n self.b2 = 2 * self.sn12[:,2] / c\\n \\n #calcula direcao de onda\\n #mean direction\\n self.dire1 = np.array([np.angle(np.complex(self.b1[i],self.a1[i]),deg=True) for i in range(len(self.a1))])\\n \\n #principal direction\\n self.dire2 = 0.5 * np.array([np.angle(np.complex(self.b2[i],self.a2[i]),deg=True) for i in range(len(self.a2))])\\n \\n #condicao para valores maiores que 360 e menores que 0\\n self.dire1[np.where(self.dire1 < 0)] = self.dire1[np.where(self.dire1 < 0)] + 360\\n self.dire1[np.where(self.dire1 > 360)] = self.dire1[np.where(self.dire1 > 360)] - 360\\n self.dire2[np.where(self.dire2 < 0)] = self.dire2[np.where(self.dire2 < 0)] + 360\\n self.dire2[np.where(self.dire2 > 360)] = self.dire2[np.where(self.dire2 > 360)] - 360\\n \\n #acha o indice da frequencia de pico\\n ind = np.where(self.sn1[:,1] == np.max(self.sn1[:,1]))[0]\\n \\n #periodo de pico\\n self.tp = (1. / self.f[ind])[0]\\n \\n #momento espectral de ordem zero total - m0\\n self.m0 = np.sum(self.sn1[:,1]) * self.df\\n \\n #calculo da altura significativa\\n self.hm0 = 4.01 * np.sqrt(self.m0)\\n \\n #direcao do periodo de pico\\n self.dp = self.dire1[ind][0]\\n \\n #Espalhamento direcional\\n #Formula do sigma1 do livro Tucker&Pitt(2001) \\\"Waves in Ocean Engineering\\\" pags 196-198\\n c1 = np.sqrt(self.a1 ** 2 + self.b1 ** 2)\\n c2 = np.sqrt(self.a2 ** 2 + self.b2 ** 2)\\n \\n s1 = c1 / (1-c1)\\n s2 = (1 + 3 * c2 + np.sqrt(1 + 14 * c2 + c2 ** 2)) / (2 * (1 - c2))\\n \\n self.sigma1 = np.sqrt(2 - 2 * c1) * 180 / np.pi\\n self.sigma2 = np.sqrt((1 - c2) / 2) * 180 / np.pi\\n \\n self.sigma1p = np.real(self.sigma1[ind])[0]\\n self.sigma2p = np.real(self.sigma2[ind])[0]\\n \\n # pondaf = np.array([hm0, tp, dp, sigma1p, sigma2p])\\n \\n #hm0, tp, dp, sigma1, sigma2, sigma1p, sigma2p, f, df, k, sn, snx, sny, snn, snnx, snny, snxny, snxnx, snyny, a1, b1, a2, b2, dire1, dire2\\n #return hm0, tp, dp, sigma1, sigma2, sigma1p, sigma2p, f, df, k, sn, snx, sny, snn, snnx, snny, snxny, snxnx, snyny, a1, b1, a2, b2, dire1, dire2\",\n \"def note(freq):\\n data = np.sin(2.0 * np.pi * freq * t) * amp\\n return data\",\n \"def sinh(x):\\n raise NotImplementedError\",\n \"def main():\\n\\n #\\n # Generate waveform\\n #\\n\\n print 'generating waveoform...'\\n waveform = pmns_utils.Waveform('shen_135135_lessvisc')\\n\\n # Pick some extrinsic parameters\\n ext_params = ExtParams(distance=1, ra=0.0, dec=0.0, polarization=0.0,\\n inclination=0.0, phase=0.0, geocent_peak_time=0.0+5.0)\\n\\n # Construct the time series for these params\\n waveform.make_wf_timeseries(theta=ext_params.inclination,\\n phi=ext_params.phase)\\n\\n #\\n # Generate IFO data\\n #\\n det1_data = DetData(waveform=waveform, ext_params=ext_params)\\n\\n from scipy import signal\\n import pylab as pl\\n\\n pl.figure()\\n pl.plot(det1_data.td_response.sample_times,det1_data.td_response.data)\\n pl.plot(det1_data.td_signal.sample_times,det1_data.td_signal.data)\\n\\n pl.figure()\\n f,p = signal.welch(det1_data.td_response.data, fs=1./det1_data.delta_t,\\n nperseg=512)\\n pl.loglog(f,np.sqrt(p))\\n\\n f,p = signal.welch(det1_data.td_signal.data, fs=1./det1_data.delta_t,\\n nperseg=512)\\n pl.loglog(f,np.sqrt(p))\\n pl.ylim(1e-25,1e-21)\\n pl.show()\",\n \"def calculate(Freq, f1, f2, stream, \\n seconds_E, seconds_P, seconds_S, \\n dt, dt_P, dt_S, Settings, dist, Acoda=None):#azBA=0):\\n \\n # save original trace\\n original_trace = stream[0].copy()\\n T0 = original_trace.stats.starttime\\n \\n sr = float(\\\"%.0f\\\" % original_trace.stats.sampling_rate) # 100 or 20 Hz normally\\n \\n if sr == 50.:\\n if Settings[\\\"verbose\\\"]:\\n print(\\\"\\\\nLets not use Irkut-24 digitizer data\\\")\\n return\\n \\n #===\\n # according to [Aki 1980] [Pavlenko 2008] [etc.]\\n # нужно брать коду за фиксированныое время - например 40 с после Т0 (время в очаге)\\n # однако для расстояний > 70 км, 40 сек будет раньше времени 2*Ts !\\n \\n #===\\n # time of Coda start\\n dt_Coda = dt + Acoda\\n \\n # how much is coda start and end in seconds\\n # cut Coda from Coda1 to Coda2 - -10s back -- +10s forward (if SD == 20)\\n Coda1, Coda2 = Acoda - SD/2, Acoda + SD/2\\n \\n # time of coda start \\n dt_Coda1 = dt + Coda1\\n # and End\\n dt_Coda2 = dt + Coda2\\n \\n # check, maybe A100 < 2*Ts, then skip it\\n if Acoda < (seconds_S * 2):\\n if Settings[\\\"verbose\\\"]:\\n print(\\\"\\\\nA`%d` amplitude is too earlier then `%.0f`!\\\" % (Acoda, Coda1))\\n # exit only if diff > 10-15 s, cause we can use anyway 1.5*Ts\\n if Acoda < (seconds_S * 2 + 10):\\n return\\n \\n # calc SD1 manually (if not set)\\n # or use fixed length for P- and S-waves\\n SD1 = Settings['sd1']\\n if SD1 == 0:\\n # window for Direct body-waves = 0.25 * Ts\\n SD1 = int( math.ceil(0.25 * seconds_S) )\\n\\n # P-wave window is half of S-window\\n SD1P = int(math.ceil(SD1 / 2))\\n \\n # check: S-window and Coda-window may intersects!\\n if (Coda1 - seconds_S) < SD1:\\n if Settings[\\\"verbose\\\"]:\\n print(\\\"\\\\nWindow S and Coda intersects for event `%s`!\\\" % dt)\\n return\\n \\n #===\\n # save resulting values here\\n result = []\\n \\n # filtering\\n filter_params = {'freqmin': f1, 'freqmax': f2, 'type': 'bandpass', \\n 'corners': Settings[\\\"corners\\\"], 'zerophase': True}\\n # Butterworth filter in place\\n stream.filter(**filter_params)\\n \\n if Settings[\\\"component\\\"] == \\\"H\\\":\\n # get ?N and ?E channels\\n __N = stream.select(channel='?HN')[0].data\\n __E = stream.select(channel='?HE')[0].data\\n # its Hilbert transform\\n hilbN = scipy.fftpack.hilbert(__N)\\n hilbE = scipy.fftpack.hilbert(__E)\\n # calc resulting components\\n __N = np.power(__N, 2) + np.power(hilbN, 2)\\n __N = np.power(__N, 0.5)\\n \\n __E = np.power(__E, 2) + np.power(hilbE, 2)\\n __E = np.power(__E, 0.5)\\n \\n # and it's Average over two channels (result of calculations)\\n RMS_component = np.mean( np.array([ __N, __E ]), axis=0 )\\n # remove 2 components\\n for _ in range(2): stream.pop(0)\\n stream[0].data = RMS_component\\n elif Settings[\\\"component\\\"] in (\\\"N\\\", \\\"E\\\", \\\"Z\\\"):# use just 1 channel\\n # channel data\\n __Z = stream.select(channel='?HZ')[0].data\\n # its Hilbert transform\\n hilbZ = scipy.fftpack.hilbert(__Z)\\n # resulting envelope\\n __Z = np.power(__Z, 2) + np.power(hilbZ, 2)\\n # square root from it\\n stream[0].data = np.power(__Z, 0.5)\\n stream[0].stats.channel = \\\"RMS\\\"\\n \\n #=== start calculating\\n # for Qp we use only Z-channel!!! for Qs - selected...\\n assert stream.count() == 1, \\\"\\\\nMust be 1 trace! we have: %s\\\" % stream\\n \\n trace = stream[0]\\n \\n # check SNR on filtered signal!\\n SNR, RMS_NOISE = calc_signal_noise_ratio(trace, sr, dt, dt_Coda2, 3)# 3 sec\\n \\n # save SNR\\n result += [SNR]\\n \\n if SNR < Settings['minsnr']:\\n if Settings[\\\"verbose\\\"]:\\n print(\\\"\\\\nSNR for freq %s is too SMALL (%.1f)!...\\\" % (Freq, SNR))\\n return result\\n \\n #===================================================================\\n #=== Calculations\\n \\n # get envelope around 40 (or 100) second, aorund Acoda\\n envelope_part = trace.slice(starttime=dt_Coda1, endtime=dt_Coda2)\\n envelope_times = envelope_part.times() + Coda1\\n \\n # calc A100 value\\n # just mean value like Eulenfeld does: tr.data = tr.data / np.mean(sl.data)\\n y100 = np.mean(envelope_part.data) # mean value\\n y100_RMS = RMS(envelope_part.data) # RMS\\n \\n #===\\n # get filtered parts of data\\n \\n # P-window data\\n # check that P-window and S-window do not intersects!\\n if (seconds_S - seconds_P) <= SD1P:\\n if Settings[\\\"verbose\\\"]:\\n print(\\\"\\\\nWindow S and P intersects for %s!\\\" % dt)\\n Pwindow = None\\n else:\\n Pwindow = stream.slice(dt_P, dt_P+SD1P)[0].data\\n \\n # S-window data\\n Swindow = stream.slice(dt_S, dt_S+SD1)[0].data\\n \\n #===========================================================================\\n # *** Crucial place for calculations ***\\n \\n # result for P-bulk-window\\n P_window_result = get_value_for_window(Pwindow, maximum=Settings[\\\"max\\\"])\\n # S-window\\n S_window_result = get_value_for_window(Swindow, maximum=Settings[\\\"max\\\"])\\n \\n #TODO: remove coda_value, we calc RMS(Acoda), A100, A40 etc\\n coda_value = 0#get_value_for_window(coda_window, maximum=Settings[\\\"max\\\"])\\n \\n # save results +A100 +slope koeff\\n result += [P_window_result, S_window_result, coda_value, y100, y100_RMS]\\n \\n #===========================================================================\\n #=== calculations Ended\\n \\n \\n #===========================================================================\\n # Move all plotting issues here, move out of calculating code\\n #===========================================================================\\n \\n if PLOT:\\n # make Figure\\n fig, (ax1, ax2) = plt.subplots(figsize=(12, 7), nrows=2, ncols=1, sharex=True)#, dpi=200)\\n \\n EVENT_NAME = \\\"Dist = {:.0f} km | Stream {}--{} | Freq {} Hz ({}-{})\\\".format(dist, \\n stream[0].stats.starttime, stream[0].stats.endtime, Freq, f1, f2)\\n fig.suptitle(EVENT_NAME, fontsize=FONTSIZE)\\n \\n # plot original signal\\n ax1.plot(original_trace.times(), np.abs(original_trace.data), \\n color=\\\"grey\\\", lw=.5, zorder=111, label=\\\"NT.%s.00.BHN+BHE\\\" % STATION)\\n # plot filtered signal\\n ax1.plot(trace.times(), trace.data, \\\"b\\\", lw=1., zorder=222, label=\\\"RMS-envelope\\\")\\n \\n # plot filtered\\n #labelFiltered = 'Фильтр {}-{} Гц'.format(f1, f2)\\n ax2.semilogy(trace.times(), trace.data, \\\"k\\\", lw=0.5, zorder=222, alpha=0.75)#label=labelFiltered, \\n \\n # mark time of Event, P and S time by vertical lines, start -- end\\n for ax in (ax1, ax2):\\n ax.axvline(x=seconds_E, linestyle=\\\"--\\\", color=\\\"y\\\", lw=2.) # Event\\n ax.axvline(x=seconds_P, linestyle=\\\"--\\\", color=\\\"b\\\", lw=0.5) # P\\n ax.axvline(x=seconds_P+SD1P, linestyle=\\\"--\\\", color=\\\"b\\\", lw=0.5) # P+SD1p\\n # S-window\\n ax.axvline(x=seconds_S, linestyle=\\\"--\\\", color=\\\"k\\\", lw=1) # S\\n ax.axvline(x=seconds_S+SD1, linestyle=\\\"--\\\", color=\\\"k\\\", lw=1) # S+SD1\\n # mark coda\\n ax.axvline(x=Coda1, linestyle=\\\"--\\\", color=\\\"r\\\", lw=2.) # coda\\n ax.axvline(x=Coda2, linestyle=\\\"--\\\", color=\\\"r\\\", lw=2) # coda\\n # mark noise RMS_NOISE\\n ax.axhline(y=RMS_NOISE, linestyle=\\\"--\\\", color=\\\"c\\\", lw=.5) # noiz\\n \\n ax1.plot(Acoda, y100, \\\"om\\\", markersize=7, markeredgecolor=\\\"k\\\", zorder=9999)\\n ax2.plot(Acoda, y100, \\\"om\\\", markersize=7, markeredgecolor=\\\"k\\\", zorder=9999)\\n \\n # mark result for S-window\\n ax2.plot(seconds_S, S_window_result, \\\"om\\\", markersize=7, \\n markeredgecolor=\\\"k\\\", zorder=999)\\n \\n # plot ec. details\\n y_pos = trace.data.max() / 2\\n \\n #=== selected windows\\n # P\\n P_time = trace.times()[:Pwindow.size] + seconds_P\\n ax2.plot(P_time, Pwindow, \\\"-r\\\", lw=1.)\\n \\n # plot S-window (Swindow)\\n S_time = trace.times()[:Swindow.size] + seconds_S\\n ax2.plot(S_time, Swindow, \\\"-r\\\", lw=1.)\\n \\n # Coda (envelope) on second axis\\n ax2.plot(envelope_times, envelope_part.data, \\\"-r\\\", lw=1.)\\n \\n # plot SNR value text\\n ax1.text(x=seconds_E+0.5, y=y_pos, s=\\\"%.1f\\\" % SNR) # SNR\\n \\n # maximum Coda amplitude\\n ax2.text(x=Coda1, y=y100_RMS, s=\\\"%.1f\\\" % y100_RMS) #coda MAX\\n \\n # axis limits\\n ax2.set_xlim(seconds_E - 5, Coda2 + 5)\\n # y\\n ax1.set_ylim(-5, original_trace.data.max())\\n ax2.set_ylim(None, trace.data.max()*1.5)\\n \\n # legend\\n ax1.legend(loc=\\\"best\\\")\\n #ax2.legend(loc=\\\"best\\\")#upper right\\n \\n plt.tight_layout()\\n \\n if Settings[\\\"show\\\"]:\\n plt.show()\\n else:\\n # just save Figure\\n save_to_dir = os.path.join(\\\"img\\\", STATION, str(stream[0].stats.starttime)[:19].replace(\\\":\\\", \\\"-\\\"))\\n if not os.path.exists(save_to_dir): os.makedirs(save_to_dir)\\n outfilename = os.path.join(save_to_dir, \\\"{}_{}_{}__{}s.png\\\".format(STATION, Settings[\\\"component\\\"], Freq, SD))\\n plt.savefig(outfilename)\\n\\n # the end\\n return result\",\n \"def sin_n(freq, frames, samplerate=SAMPLERATE):\\n global PHASE\\n t = np.arange(frames)/ samplerate\\n out = np.sin(2 * np.pi * freq * t + PHASE).reshape(-1,1) \\n PHASE += 2 * np.pi * (freq * (t[-1]+t[1])) # phase shift\\n return out\",\n \"def test_sinusoid():\\n generator = SignalGenerator(sr=100)\\n data = generator.sinusoid(noise_stds=[0, 0, 0])\\n freq_features = FrequencyFeature(data, sr=100)\\n freq_features.fft().peaks()\\n dom_freqs = freq_features.dominant_frequency(n=1)\\n dom_freqs_second = freq_features.dominant_frequency(n=2)\\n assert np.allclose(dom_freqs, np.array([1, 2, 3]))\\n assert np.allclose(dom_freqs_second, np.array([-1, -1, -1]))\",\n \"def create_sinus_plus_brownian_noise_scenario(missing_percentage, periodparameter, scenario_name, days = 2555, seasonalperiodparam=None):\\n # The stockprice is a brownian motion 7 days a week all year. \\n total_days = days\\n noise = b.gen_normal(days)\\n days = np.arange(total_days)\\n sinus = np.sin(days/periodparameter)\\n noisy_sin = sinus+1.2*noise\\n if(seasonalperiodparam):\\n seasonal_sin = sinus = np.sin(days/seasonalperiodparam)\\n noisy_sin = noisy_sin + seasonal_sin\\n \\n # The sp_no_missing_values will take the allyear stockprice and remove the weekends + 7 days a year random holidays.\\n sin_random_missing = copy.deepcopy(noisy_sin)\\n\\n missing_counter = 0\\n\\n while(missing_counter < missing_percentage*(total_days)):\\n randomday = random.randint(0, total_days-1)\\n if(sin_random_missing[randomday] != np.nan):\\n sin_random_missing[randomday] = np.nan\\n missing_counter = missing_counter + 1\\n\\n plt.figure(figsize=(9,4))\\n plt.plot(sin_random_missing)\\n plt.legend([scenario_name],\\n loc='upper left')\\n if(seasonalperiodparam):\\n plt.title(\\\"noisy sin with random 33% missing values with seasonality\\\")\\n else:\\n plt.title(\\\"noisy sin with every 3rd value missing\\\")\\n\\n plt.show()\\n \\n sin_regular_missing = copy.deepcopy(noisy_sin)\\n day = 0\\n while(day < total_days):\\n if(day%3 == 2):\\n sin_regular_missing[day] = np.nan\\n day = day + 1\\n\\n plt.figure(figsize=(9,4))\\n plt.plot(sin_regular_missing)\\n plt.legend([scenario_name],\\n loc='upper left')\\n if(seasonalperiodparam):\\n plt.title(\\\"noisy sin with every 3rd value missing with seasonality\\\")\\n else:\\n plt.title(\\\"noisy sin with every 3rd value missing\\\")\\n plt.show()\\n \\n dict = {'noisy_sin': noisy_sin, 'noisy_sin_random_missing': sin_random_missing, 'noisy_sin_regular_missing': sin_regular_missing}\\n df = pd.DataFrame(dict)\\n if scenario_name:\\n output_loc = 'synthetic_data/univariate_missingness/' + scenario_name\\n df.to_csv(output_loc)\\n return noisy_sin\",\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 test_sin_con():\\n c=14\\n assert {'diff':EF.sin(c).der, 'value': EF.sin(c).val}=={'diff':0, 'value': math.sin(c)}\",\n \"def abrahamson_silva_ds_1999(magnitude=7.0,distance=10.0,soil=True,duration_type='DS575H'):\\n\\n\\n # map the duration_type to integer key\\n dur_map = {'DS575H': 0,\\n 'DS575V': 1,\\n 'DS595H': 2,\\n 'DS595V': 3}\\n dur_tag = dur_map.get(duration_type.upper(),None)\\n if dur_tag is None:\\n print(\\\"SignificantDurationModel.abrahamson_silva_ds_1999: duration_type='DS575H','DS575V','DS595H','DS595V'?\\\")\\n return None, None\\n # modeling coefficients\\n beta = [3.2, 3.2, 3.2, 3.2]\\n b1 = [5.204, 4.610, 5.204, 4.610]\\n b2 = [0.851, 1.536, 0.851, 1.536]\\n m_star = [6, 6, 6, 6]\\n c1 = [0.805, 1.076, 0.805, 1.076]\\n c2 = [0.063, 0.107, 0.063, 0.107]\\n rc = [10, 10, 10, 10]\\n Drat = [0.000, 0.000, 0.845, 0.646]\\n sigma = [0.55, 0.46, 0.49, 0.45]\\n # median\\n if distance > rc[dur_tag]:\\n ds_median = np.exp(np.log((np.exp(b1[dur_tag]+b2[dur_tag]* \\\\\\n (magnitude-m_star[dur_tag]))/(10**(1.5*magnitude+ \\\\\\n 16.05)))**(-1/3)/(4.9e6*beta[dur_tag])+soil* \\\\\\n c1[dur_tag]+c2[dur_tag]*(distance-rc[dur_tag]))+Drat[dur_tag])\\n else:\\n ds_median = np.exp(np.log((np.exp(b1[dur_tag]+b2[dur_tag]* \\\\\\n (magnitude-m_star[dur_tag]))/(10**(1.5*magnitude+ \\\\\\n 16.05)))**(-1/3)/(4.9e6*beta[dur_tag])+soil* \\\\\\n c1[dur_tag])+Drat[dur_tag])\\n # sigma\\n ds_sigma = sigma[dur_tag]\\n\\n # return\\n return np.log(ds_median), ds_sigma\",\n \"def dfluxes(wavelength, s, line1, line2, lowlow= 25, lowhigh=15, highlow=15, highhigh = 25, \\n lmin=0, lmax=0, fmin=0, fmax=0,\\n broad1=2.355, broad2=2.355, sus_line1=True, sus_line2=True,\\n plot=True, verbose=True, plot_sus = False, fcal = True, \\n fit_continuum = True, median_kernel=35, warnings = True ): # Broad is FWHM for Gaussian sigma= 1, \\n # Setup wavelength limits\\n if lmin == 0 :\\n lmin = line1-65. # By default, +-65 A with respect to line\\n if lmax == 0 :\\n lmax = line2+65.\\n \\n # Extract subrange to fit\\n w_spec = []\\n f_spec = []\\n w_spec.extend((wavelength[i]) for i in range(len(wavelength)) if (wavelength[i] > lmin and wavelength[i] < lmax) ) \\n f_spec.extend((s[i]) for i in range(len(wavelength)) if (wavelength[i] > lmin and wavelength[i] < lmax) ) \\n \\n \\n if np.nanmedian(f_spec) == np.nan: print(\\\" NO HAY DATOS.... todo son NANs!\\\")\\n\\n \\n # Setup min and max flux values in subrange to fit\\n if fmin == 0 :\\n fmin = np.nanmin(f_spec) \\n if fmax == 0 :\\n fmax = np.nanmax(f_spec) \\n \\n\\n # We have to find some \\\"guess numbers\\\" for the Gaussian\\n # Now guess_centre is line\\n guess_centre1 = line1\\n guess_centre2 = line2 \\n guess_centre = (guess_centre1+guess_centre2)/2. \\n # Define continuum regions: [-lowlow, -lowhigh] and [highlow,highhigh] in Angstroms with respect to guess_centre\\n \\n\\n w_cont=[]\\n f_cont=[]\\n w_cont.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-lowlow and w_spec[i] < guess_centre-lowhigh) or (w_spec[i] > guess_centre+highlow and w_spec[i] < guess_centre+highhigh) ) \\n f_cont.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-lowlow and w_spec[i] < guess_centre-lowhigh) or (w_spec[i] > guess_centre+highlow and w_spec[i] < guess_centre+highhigh) ) \\n\\n if fit_continuum:\\n # Linear Fit to continuum \\n f_cont_filtered=sig.medfilt(f_cont,np.int(median_kernel))\\n try: \\n mm,bb = np.polyfit(w_cont, f_cont_filtered, 1)\\n except Exception:\\n bb = np.nanmedian(f_cont_filtered)\\n mm = 0.\\n if warnings: \\n print(\\\" WARNING: Impossible to get the continuum!\\\")\\n print(\\\" Scaling the continuum to the median value\\\") \\n continuum = mm*np.array(w_spec)+bb \\n c_cont = mm*np.array(w_cont)+bb \\n\\n else: \\n # Median value in each continuum range # NEW 15 Sep 2019\\n w_cont_low = []\\n f_cont_low = []\\n w_cont_low.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-lowlow and w_spec[i] < guess_centre-lowhigh) ) \\n f_cont_low.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre-lowlow and w_spec[i] < guess_centre-lowhigh) ) \\n median_w_cont_low = np.nanmedian(w_cont_low)\\n median_f_cont_low = np.nanmedian(f_cont_low)\\n w_cont_high = []\\n f_cont_high = []\\n w_cont_high.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre+highlow and w_spec[i] < guess_centre+highhigh) ) \\n f_cont_high.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre+highlow and w_spec[i] < guess_centre+highhigh) ) \\n median_w_cont_high = np.nanmedian(w_cont_high)\\n median_f_cont_high = np.nanmedian(f_cont_high) \\n \\n b = (median_f_cont_low-median_f_cont_high)/(median_w_cont_low-median_w_cont_high)\\n a = median_f_cont_low- b * median_w_cont_low\\n \\n continuum = a + b*np.array(w_spec)\\n c_cont = b*np.array(w_cont)+ a \\n \\n # rms continuum\\n rms_cont = np.nansum([ np.abs(f_cont[i] - c_cont[i]) for i in range(len(w_cont)) ]) / len(c_cont)\\n\\n # Search for index here w_spec(index) closest to line\\n min_w = np.abs(np.array(w_spec)-line1)\\n mini = np.nanmin(min_w)\\n guess_peak1 = f_spec[min_w.tolist().index(mini)] - continuum[min_w.tolist().index(mini)]\\n min_w = np.abs(np.array(w_spec)-line2)\\n mini = np.nanmin(min_w)\\n guess_peak2 = f_spec[min_w.tolist().index(mini)] - continuum[min_w.tolist().index(mini)]\\n\\n # Search for beginning/end of emission line, choosing line +-10 \\n # 28th Feb 2019: Check central value between low_limit and high_limit\\n\\n # LOW limit\\n low_limit=0\\n w_fit = []\\n f_fit = []\\n w_fit.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre1-15 and w_spec[i] < guess_centre1)) \\n f_fit.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre1-15 and w_spec[i] < guess_centre1)) \\n if fit_continuum: \\n c_fit=mm*np.array(w_fit)+bb \\n else: \\n c_fit=b*np.array(w_fit)+a\\n \\n\\n fs=[]\\n ws=[]\\n for ii in range(len(w_fit)-1,1,-1):\\n if f_fit[ii]/c_fit[ii] < 1.05 and f_fit[ii-1]/c_fit[ii-1] < 1.05 and low_limit == 0: low_limit = w_fit[ii]\\n# if f_fit[ii]/c_fit[ii] < 1.05 and low_limit == 0: low_limit = w_fit[ii]\\n fs.append(f_fit[ii]/c_fit[ii])\\n ws.append(w_fit[ii])\\n if low_limit == 0: \\n sorted_by_flux=np.argsort(fs)\\n low_limit = ws[sorted_by_flux[0]]\\n \\n # HIGH LIMIT \\n high_limit=0\\n w_fit = []\\n f_fit = []\\n w_fit.extend((w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre2 and w_spec[i] < guess_centre2+15)) \\n f_fit.extend((f_spec[i]) for i in range(len(w_spec)) if (w_spec[i] > guess_centre2 and w_spec[i] < guess_centre2+15)) \\n if fit_continuum: \\n c_fit=mm*np.array(w_fit)+bb \\n else: \\n c_fit=b*np.array(w_fit)+a\\n \\n fs=[]\\n ws=[]\\n for ii in range(len(w_fit)-1):\\n if f_fit[ii]/c_fit[ii] < 1.05 and f_fit[ii+1]/c_fit[ii+1] < 1.05 and high_limit == 0: high_limit = w_fit[ii]\\n# if f_fit[ii]/c_fit[ii] < 1.05 and high_limit == 0: high_limit = w_fit[ii]\\n fs.append(f_fit[ii]/c_fit[ii])\\n ws.append(w_fit[ii])\\n if high_limit == 0: \\n sorted_by_flux=np.argsort(fs)\\n high_limit = ws[sorted_by_flux[0]] \\n \\n # Fit a Gaussian to data - continuum \\n p0 = [guess_centre1, guess_peak1, broad1/2.355, guess_centre2, guess_peak2, broad2/2.355] # broad is the Gaussian sigma, 1.0 for emission lines\\n try:\\n fit, pcov = curve_fit(dgauss, w_spec, f_spec-continuum, p0=p0, maxfev=10000) # If this fails, increase maxfev...\\n fit_error = np.sqrt(np.diag(pcov))\\n\\n\\n # New 28th Feb 2019: Check central value between low_limit and high_limit\\n # Better: between guess_centre - broad, guess_centre + broad\\n # If not, redo fit fixing central value to the peak (it does not work... just fix FWHM= (high_limit-low_limit)/2.5 )\\n\\n if verbose != False: print(\\\" ----------------------------------------------------------------------------------------\\\")\\n if fit[0] < guess_centre1 - broad1 or fit[0] > guess_centre1 + broad1 or fit[3] < guess_centre2 - broad2 or fit[3] > guess_centre2 + broad2:\\n if warnings: \\n if fit[0] < guess_centre1 - broad1 or fit[0] > guess_centre1 + broad1: \\n print(\\\" Fitted center wavelength\\\", fit[0],\\\"is NOT in the expected range [\\\",guess_centre1 - broad1,\\\",\\\",guess_centre1 + broad1,\\\"]\\\")\\n else:\\n print(\\\" Fitted center wavelength\\\", fit[0],\\\"is in the expected range [\\\",guess_centre1 - broad1,\\\",\\\",guess_centre1 + broad1,\\\"]\\\")\\n if fit[3] < guess_centre2 - broad2 or fit[3] > guess_centre2 + broad2: \\n print(\\\" Fitted center wavelength\\\", fit[3],\\\"is NOT in the expected range [\\\",guess_centre2 - broad2,\\\",\\\",guess_centre2 + broad2,\\\"]\\\")\\n else:\\n print(\\\" Fitted center wavelength\\\", fit[3],\\\"is in the expected range [\\\",guess_centre2 - broad2,\\\",\\\",guess_centre2 + broad2,\\\"]\\\")\\n print(\\\" Fit failed!\\\")\\n \\n fit[0]=guess_centre1\\n fit_error[0] = 0.000001\\n fit[1]=guess_peak1\\n fit_error[1] = 0.000001\\n fit[2] = broad1/2.355\\n fit_error[2] = 0.000001 \\n fit[3]=guess_centre2\\n fit_error[3] = 0.000001\\n fit[4]=guess_peak2\\n fit_error[4] = 0.000001\\n fit[5] = broad2/2.355\\n fit_error[5] = 0.000001\\n else:\\n if warnings: print(\\\" Fitted center wavelength\\\", fit[0],\\\"is in the expected range [\\\",guess_centre1 - broad1,\\\",\\\",guess_centre1 + broad1,\\\"]\\\")\\n if warnings: print(\\\" Fitted center wavelength\\\", fit[3],\\\"is in the expected range [\\\",guess_centre2 - broad2,\\\",\\\",guess_centre2 + broad2,\\\"]\\\")\\n \\n\\n if warnings: \\n print(\\\" Fit parameters = \\\", fit[0], fit[1], fit[2]) \\n print(\\\" \\\", fit[3], fit[4], fit[5])\\n if fit[2] == broad1/2.355 and warnings == True : \\n print(\\\" WARNING: Fit in\\\",fit[0],\\\"failed! Using given centre wavelengths (cw), peaks at (cv) & sigmas=broad/2.355 given.\\\") # CHECK THIS \\n\\n gaussian_fit = dgauss(w_spec, fit[0], fit[1], fit[2],fit[3], fit[4], fit[5])\\n \\n gaussian_1 = gauss(w_spec, fit[0], fit[1], fit[2])\\n gaussian_2 = gauss(w_spec, fit[3], fit[4], fit[5])\\n \\n\\n # Estimate rms of the Gaussian fit in range [low_limit, high_limit]\\n residuals = f_spec-gaussian_fit-continuum\\n rms_fit = np.nansum([ ((residuals[i]**2)/(len(residuals)-2))**0.5 for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \\n \\n # Fluxes, FWHM and Eq. Width calculations # CHECK THIS , not well done for dfluxes !!!\\n \\n gaussian_flux_1 = gauss_flux(fit[1],fit[2])\\n gaussian_flux_2 = gauss_flux(fit[4],fit[5]) \\n gaussian_flux = gaussian_flux_1+ gaussian_flux_2 \\n if warnings: \\n print(\\\" Gaussian flux = \\\", gaussian_flux_1, \\\" + \\\",gaussian_flux_2,\\\" = \\\",gaussian_flux)\\n print(\\\" Gaussian ratio = \\\", gaussian_flux_1/gaussian_flux_2)\\n \\n error1 = np.abs(gauss_flux(fit[1]+fit_error[1],fit[2]) - gaussian_flux)\\n error2 = np.abs(gauss_flux(fit[1],fit[2]+fit_error[2]) - gaussian_flux)\\n gaussian_flux_error = 1 / ( 1/error1**2 + 1/error2**2 )**0.5\\n \\n fwhm=fit[2]*2.355\\n fwhm_error = fit_error[2] *2.355\\n fwhm_vel = fwhm / fit[0] * C \\n fwhm_vel_error = fwhm_error / fit[0] * C \\n \\n gaussian_ew = gaussian_flux/np.nanmedian(f_cont)\\n gaussian_ew_error = gaussian_ew * gaussian_flux_error/gaussian_flux \\n \\n # Integrated flux\\n # IRAF: flux = sum ((I(i)-C(i)) * (w(i2) - w(i1)) / (i2 - i2) \\n flux = np.nansum([ (f_spec[i]-continuum[i])*(w_spec[i+1]-w_spec[i]) for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \\n flux_error = rms_cont * (high_limit - low_limit)\\n wave_resolution = (wavelength[-1]-wavelength[0])/len(wavelength)\\n ew = wave_resolution * np.nansum ([ (1 - f_spec[i]/continuum[i]) for i in range(len(w_spec)) if (w_spec[i] >= low_limit and w_spec[i] <= high_limit) ]) \\n ew_error = np.abs(ew*flux_error/flux) \\n gauss_to_integrated = gaussian_flux/flux * 100.\\n \\n # Plotting \\n if plot :\\n plt.figure(figsize=(10, 4))\\n #Plot input spectrum\\n plt.plot(np.array(w_spec),np.array(f_spec), \\\"blue\\\", lw=2, alpha = 0.7)\\n plt.minorticks_on() \\n plt.xlabel(\\\"Wavelength [$\\\\mathrm{\\\\AA}$]\\\")\\n if fcal:\\n plt.ylabel(\\\"Flux [ erg cm$^{-2}$ s$^{-1}$ $\\\\mathrm{\\\\AA}^{-1}$ ]\\\")\\n else:\\n plt.ylabel(\\\"Flux [ counts ]\\\")\\n plt.xlim((line1+line2)/2-40,(line1+line2)/2+40)\\n plt.ylim(fmin,fmax)\\n \\n # Vertical line at guess_centre\\n plt.axvline(x=guess_centre1, color='r', linestyle='-', alpha=0.5)\\n plt.axvline(x=guess_centre2, color='r', linestyle='-', alpha=0.5)\\n\\n # Horizontal line at y = 0\\n plt.axhline(y=0, color='k', linestyle=':', alpha=0.5) \\n # Dashed green regions for continuum, defined by [lowlow, lowhigh] and [highlow,highhigh]\\n plt.axvspan(guess_centre+highlow, guess_centre+highhigh, facecolor='g', alpha=0.15,zorder=3)\\n plt.axvspan(guess_centre-lowlow, guess_centre-lowhigh, facecolor='g', alpha=0.15,zorder=3)\\n # Plot linear fit for continuum\\n plt.plot(w_spec, continuum,\\\"g--\\\")\\n # Plot Gaussian fit \\n plt.plot(w_spec, gaussian_fit+continuum, 'r-', alpha=0.8) \\n # Vertical line at Gaussian center\\n plt.axvline(x=fit[0], color='k', linestyle='-', alpha=0.5)\\n plt.axvline(x=fit[3], color='k', linestyle='-', alpha=0.5)\\n # Plot Gaussians + cont\\n plt.plot(w_spec, gaussian_fit+continuum, 'r-', alpha=0.5, lw=3) \\n plt.plot(w_spec, gaussian_1+continuum, color=\\\"navy\\\",linestyle='--', alpha=0.8)\\n plt.plot(w_spec, gaussian_2+continuum, color=\\\"#1f77b4\\\",linestyle='--', alpha=0.8)\\n plt.plot(w_spec, np.array(f_spec)-(gaussian_fit), 'orange', alpha=0.4, linewidth=5) \\n\\n # Vertical lines to emission line\\n plt.axvline(x= low_limit, color='k', linestyle=':', alpha=0.5)\\n plt.axvline(x= high_limit, color='k', linestyle=':', alpha=0.5) \\n plt.title('Double Gaussian Fit') # Fit: x0=%.2f y0=%.2e sigma=%.2f flux=%.2e rms=%.3e' % (fit[0], fit[1], fit[2], gaussian_flux, rms_fit))\\n plt.show()\\n plt.close()\\n \\n # Plot residuals\\n# plt.figure(figsize=(10, 1))\\n# plt.xlabel(\\\"Wavelength [$\\\\mathrm{\\\\AA}$]\\\")\\n# plt.ylabel(\\\"RMS\\\")\\n# plt.xlim((line1+line2)/2-40,(line1+line2)/2+40)\\n# plt.axvline(x=fit[0], color='k', linestyle='-', alpha=0.5)\\n# plt.axvline(x=fit[3], color='k', linestyle='-', alpha=0.5)\\n# plt.plot(w_spec, residuals, 'k')\\n# plt.minorticks_on()\\n# plt.show()\\n# plt.close()\\n\\n \\n # Printing results\\n if verbose :\\n #print \\\"\\\\n> WARNING !!! CAREFUL WITH THE VALUES PROVIDED BELOW, THIS TASK NEEDS TO BE UPDATED!\\\\n\\\"\\n print(\\\"\\\\n> Gauss and continuum fitting + integrated flux calculations:\\\\n\\\")\\n print(\\\" rms continuum = %.3e erg/cm/s/A \\\" % (rms_cont)) \\n print(\\\" Gaussian Fit parameters: x0 = ( %.2f +- %.2f ) A \\\" % (fit[0], fit_error[0]))\\n print(\\\" y0 = ( %.3f +- %.3f ) 1E-16 erg/cm2/s/A\\\" % (fit[1]/1E-16, fit_error[1]/1E-16 ))\\n print(\\\" sigma = ( %.3f +- %.3f ) A\\\" % (fit[2], fit_error[2])) \\n print(\\\" rms fit = %.3e erg/cm2/s/A\\\" % (rms_fit))\\n print(\\\" Gaussian Flux = ( %.2f +- %.2f ) 1E-16 erg/s/cm2 (error = %.1f per cent)\\\" % (gaussian_flux/1E-16, gaussian_flux_error/1E-16, gaussian_flux_error/gaussian_flux*100))\\n print(\\\" FWHM = ( %.3f +- %.3f ) A = ( %.1f +- %.1f ) km/s \\\" % (fwhm, fwhm_error, fwhm_vel, fwhm_vel_error))\\n print(\\\" Eq. Width = ( %.1f +- %.1f ) A\\\" % (-gaussian_ew, gaussian_ew_error)) \\n print(\\\"\\\\n Integrated flux = ( %.2f +- %.2f ) 1E-16 erg/s/cm2 (error = %.1f per cent) \\\" % ( flux/1E-16, flux_error/1E-16, flux_error/flux *100)) \\n print(\\\" Eq. Width = ( %.1f +- %.1f ) A\\\" % (ew, ew_error))\\n print(\\\" Gauss/Integrated = %.2f per cent \\\" % gauss_to_integrated)\\n \\n \\n # New 22 Jan 2019: sustract Gaussian fit\\n index=0\\n s_s=np.zeros_like(s)\\n sustract_this = np.zeros_like(gaussian_fit)\\n if sus_line1:\\n sustract_this = sustract_this + gaussian_1\\n if sus_line2:\\n sustract_this = sustract_this + gaussian_2 \\n \\n \\n for wave in range(len(wavelength)):\\n s_s[wave]=s[wave]\\n if wavelength[wave] == w_spec[0] : \\n s_s[wave] = f_spec[0]-sustract_this[0]\\n index=1\\n if wavelength[wave] > w_spec[0] and wavelength[wave] <= w_spec[-1]:\\n s_s[wave] = f_spec[index]-sustract_this[index]\\n index=index+1\\n if plot_sus: \\n plt.figure(figsize=(10, 4))\\n plt.plot(wavelength,s, \\\"r\\\")\\n plt.plot(wavelength,s_s, \\\"c\\\")\\n plt.minorticks_on() \\n plt.xlabel(\\\"Wavelength [$\\\\mathrm{\\\\AA}$]\\\")\\n if fcal:\\n plt.ylabel(\\\"Flux [ erg cm$^{-2}$ s$^{-1}$ $\\\\mathrm{\\\\AA}^{-1}$ ]\\\")\\n else:\\n plt.ylabel(\\\"Flux [ counts ]\\\")\\n plt.xlim(lmin,lmax)\\n plt.ylim(fmin,fmax)\\n plt.show()\\n plt.close()\\n \\n # This gaussian_flux in 3 is gaussian 1 + gaussian 2, given in 15, 16, respectively\\n # 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16\\n resultado = [rms_cont, fit[0], fit_error[0], gaussian_flux, gaussian_flux_error, fwhm, fwhm_error, flux, flux_error, ew, ew_error, s_s, fit[3], fit[4],fit[5], gaussian_flux_1, gaussian_flux_2 ]\\n return resultado \\n except Exception:\\n if verbose: print(\\\" Double Gaussian fit failed!\\\")\\n resultado = [0, line1, 0, 0, 0, 0, 0, 0, 0, 0, 0, s, 0, 0, 0, 0, 0 ] # line was identified at lambda=line but Gaussian fit failed\\n\\n # NOTA: PUEDE DEVOLVER EL FLUJO INTEGRADO AUNQUE FALLE EL AJUSTE GAUSSIANO...\\n\\n # Plotting \\n if plot :\\n plt.figure(figsize=(10, 4))\\n plt.plot(np.array(w_spec),np.array(f_spec), \\\"b\\\", lw=3, alpha = 0.5)\\n plt.minorticks_on() \\n plt.xlabel(\\\"Wavelength [$\\\\mathrm{\\\\AA}$]\\\")\\n if fcal:\\n plt.ylabel(\\\"Flux [ erg cm$^{-2}$ s$^{-1}$ $\\\\mathrm{\\\\AA}^{-1}$ ]\\\")\\n else:\\n plt.ylabel(\\\"Flux [ counts ]\\\") \\n plt.xlim(lmin,lmax)\\n plt.ylim(fmin,fmax)\\n \\n # Vertical line at guess_centre\\n plt.axvline(x=guess_centre, color='r', linestyle='-', alpha=0.5)\\n # Horizontal line at y = 0\\n plt.axhline(y=0, color='k', linestyle=':', alpha=0.5) \\n # Dashed green regions for continuum, defined by [lowlow, lowhigh] and [highlow,highhigh]\\n plt.axvspan(guess_centre+highlow, guess_centre+highhigh, facecolor='g', alpha=0.15,zorder=3)\\n plt.axvspan(guess_centre-lowlow, guess_centre-lowhigh, facecolor='g', alpha=0.15,zorder=3)\\n # Plot linear fit for continuum\\n plt.plot(w_spec, continuum,\\\"g--\\\")\\n # Plot Gaussian fit \\n# plt.plot(w_spec, gaussian_fit+continuum, 'r-', alpha=0.8) \\n # Vertical line at Gaussian center\\n# plt.axvline(x=fit[0], color='k', linestyle='-', alpha=0.5)\\n # Vertical lines to emission line\\n plt.axvline(x= low_limit, color='k', linestyle=':', alpha=0.5)\\n plt.axvline(x= high_limit, color='k', linestyle=':', alpha=0.5) \\n # Plot residuals\\n# plt.plot(w_spec, residuals, 'k')\\n plt.title(\\\"No Gaussian fit obtained...\\\")\\n plt.show()\\n\\n\\n return resultado\",\n \"def test_Morlet():\\n morl = cw.MorletWave()\\n assert(np.isclose(morl(0), np.pi**(-1/4), atol=1.e-12))\\n assert(np.isclose(morl.freq(0), 0, atol=1.e-12))\",\n \"def test_get_spectra_bi():\\r\\n\\r\\n methods = (None,\\r\\n {\\\"this_method\\\": 'welch', \\\"NFFT\\\": 256, \\\"Fs\\\": 2 * np.pi},\\r\\n {\\\"this_method\\\": 'welch', \\\"NFFT\\\": 1024, \\\"Fs\\\": 2 * np.pi})\\r\\n\\r\\n for method in methods:\\r\\n arsig1, _, _ = utils.ar_generator(N=2 ** 16)\\r\\n arsig2, _, _ = utils.ar_generator(N=2 ** 16)\\r\\n\\r\\n avg_pwr1 = (arsig1 ** 2).mean()\\r\\n avg_pwr2 = (arsig2 ** 2).mean()\\r\\n avg_xpwr = (arsig1 * arsig2.conjugate()).mean()\\r\\n\\r\\n tseries = np.vstack([arsig1, arsig2])\\r\\n\\r\\n f, fxx, fyy, fxy = tsa.get_spectra_bi(arsig1, arsig2, method=method)\\r\\n\\r\\n # \\\\sum_{\\\\omega} PSD(\\\\omega) d\\\\omega:\\r\\n est_pwr1 = np.sum(fxx * (f[1] - f[0]))\\r\\n est_pwr2 = np.sum(fyy * (f[1] - f[0]))\\r\\n est_xpwr = np.sum(fxy * (f[1] - f[0])).real\\r\\n\\r\\n # Test that we have the right order of magnitude:\\r\\n npt.assert_array_almost_equal(est_pwr1, avg_pwr1, decimal=-1)\\r\\n npt.assert_array_almost_equal(est_pwr2, avg_pwr2, decimal=-1)\\r\\n npt.assert_array_almost_equal(np.mean(est_xpwr),\\r\\n np.mean(avg_xpwr),\\r\\n decimal=-1)\",\n \"def test_freq(self):\\n model = BDF(debug=False)\\n sid = 101\\n freqs = 0.1\\n freq = model.add_freq(sid, freqs, comment='freq')\\n #print(freq)\\n\\n freqs = [2.0, 3.0]\\n freq = model.add_freq(sid, freqs, comment='freq')\\n #print(freq)\\n\\n f1 = 0.\\n df = 2.0\\n freq1 = model.add_freq1(sid, f1, df, ndf=5, comment='freq1')\\n assert len(freq1.freqs) == 6, 'freqs=%s' % freq1.freqs\\n #print(freq1)\\n\\n f1 = 1.\\n f2 = 8.0\\n freq2 = model.add_freq2(sid, f1, f2, nf=6, comment='freq2')\\n assert len(freq2.freqs) == 7, 'freqs=%s' % freq2.freqs\\n assert np.allclose(freq2.freqs.max(), f2), freq2.freqs\\n #print(freq2)\\n\\n freq4 = model.add_freq4(sid, f1, f2, fspread=0.1, nfm=3, comment='freq4')\\n #print(model.frequencies[sid])\\n #print(freq4)\\n\\n fractions = [0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]\\n freq5 = model.add_freq5(sid, fractions, f1=0., f2=100., comment='freq5')\\n\\n fractions = np.linspace(0., 1.)\\n unused_freq5b = model.add_freq5(sid, fractions, f1=0., f2=100., comment='freq5')\\n model.validate()\\n\\n freq.raw_fields()\\n freq.write_card()\\n freq.write_card(size=16)\\n\\n freq1.raw_fields()\\n freq1.write_card()\\n freq1.write_card(size=16)\\n\\n freq2.raw_fields()\\n freq2.write_card()\\n freq2.write_card(size=16)\\n\\n freq4.raw_fields()\\n freq4.write_card()\\n freq4.write_card(size=16)\\n\\n freq5.raw_fields()\\n freq5.write_card()\\n freq5.write_card(size=16)\\n\\n bdf_file = StringIO()\\n model.write_bdf(bdf_file, close=False)\\n unused_out = bdf_file.getvalue()\\n bdf_file.seek(0)\\n\\n model2 = read_bdf(bdf_file, punch=True, debug=False)\\n model2.uncross_reference()\\n model2.safe_cross_reference()\\n model2.uncross_reference()\\n save_load_deck(model)\",\n \"def create_sinus_scenario(missing_percentage, periodparameter, scenario_name):\\n # The stockprice is a brownian motion 7 days a week all year. \\n total_days = 1460\\n days = np.arange(total_days)\\n sinus = np.sin(days/periodparameter)\\n\\n # The sp_no_missing_values will take the allyear stockprice and remove the weekends + 7 days a year random holidays.\\n sin_missing_values = copy.deepcopy(sinus)\\n\\n\\n missing_counter = 0\\n\\n while(missing_counter < missing_percentage*(total_days)):\\n randomday = random.randint(0, total_days)\\n if(sin_missing_values[randomday] != np.nan):\\n sin_missing_values[randomday] = np.nan\\n missing_counter = missing_counter + 1\\n\\n plt.figure(figsize=(9,4))\\n plt.plot(sin_missing_values)\\n plt.legend([scenario_name],\\n loc='upper left')\\n plt.show()\\n\\n \\n dict = {'sinus': sinus, 'noisy_sin_missing_values': sin_missing_values} \\n df = pd.DataFrame(dict)\\n output_loc = 'synthetic_data/sinus_scenarios/' + scenario_name\\n df.to_csv(output_loc)\\n return noisy_sin\",\n \"def setUp(self):\\n shape = RNG.integers(5, 50)\\n periods = self.periods = RNG.normal() * 3\\n freq = periods / shape\\n amp = RNG.normal()\\n offset = RNG.normal()\\n phase = (RNG.normal() - 1 / 2) * 5 / 3 * np.pi\\n p_gt = self.p_gt = (amp, freq, phase, offset)\\n x = self.x = np.arange(shape)\\n self.data = sine(x, *p_gt)\",\n \"def sinh(self):\\t\\t\\n\\t\\tval = np.sinh(self.val)\\n\\t\\tif len(self.der.shape):\\n\\t\\t\\tto_multiply = np.cosh(self.val)\\n\\t\\t\\tto_multiply = np.expand_dims(to_multiply, 1) if len(self.der.shape) > len(to_multiply.shape) else to_multiply\\n\\t\\t\\tder = to_multiply * self.der\\n\\t\\telse:\\n\\t\\t\\tder = None\\n\\t\\treturn Var(val, der)\",\n \"def sin_transition(freq1, freq2, frames, samplerate=SAMPLERATE):\\n global PHASE\\n\\n t = np.arange(frames)/ samplerate\\n G = (freq2*t*t - freq1*(t[-1]-t)*(t[-1]-t))/2/t[-1] + t[-1]/2*freq1 # integrates (1-t)f1 + t*f2\\n out = np.sin(2 * np.pi * G + PHASE).reshape(-1,1) \\n PHASE += 2 * np.pi * (G[-1] + freq2*t[1]) # phase shift\\n return out\",\n \"def sinh(x):\\n return 0.0\",\n \"def test_lightcurve_seismology_plot():\\n KeplerLightCurveFile(TABBY_Q8).PDCSAP_FLUX.periodogram().plot()\",\n \"def sin_transition4(freq1, freq2, frames, start_idx=0, samplerate=SAMPLERATE):\\n t = (start_idx + np.arange(frames)) / samplerate\\n t = t.reshape(-1, 1)\\n phase = (freq2*(t-t[0])*(t-t[0]) - freq1*(t[-1]-t)*(t[-1]-t))/2/(t[-1]-t[0]) \\n return np.sin(2 * np.pi * phase).reshape(-1,1)\",\n \"def sincbroad(w, s, hwhm):\\n \\\"\\\"\\\"\\n History\\n -------\\n Dec-90 GB,GM\\n Rewrote with fourier convolution algorithm.\\n Jul-91 AL\\n Translated from ANA to IDL.\\n 22-Sep-91 JAV\\n Relaxed constant dispersion check# vectorized, 50% faster.\\n 05-Jul-92 JAV\\n Converted to function, handle nonpositive hwhm.\\n 14-Nov-93 JAV\\n Adapted from macbro.pro\\n 23-Apr-93 JAV\\n Verified that convolution kernel has specified hwhm. For IR FTS\\n spectra: hwhm=0.0759 Angstroms, max change in profile is 0.4% of continuum.\\n Oct-18 AW\\n Python Version\\n \\\"\\\"\\\"\\n\\n # Warn user if hwhm is negative.\\n if hwhm < 0:\\n logger.warning(\\\"Forcing negative smoothing width to zero.\\\")\\n\\n # Return input argument if half-width is nonpositive.\\n if hwhm <= 0:\\n return s # true: no broadening\\n\\n # Calculate (uniform) dispersion.\\n nw = len(w) ## points in spectrum\\n dw = (w[-1] - w[0]) / (nw - 1) # wavelength change per pixel\\n\\n # Make sinc function out to 20th zero-crossing on either side. Error due to\\n # ignoring additional lobes is less than 0.2% of continuum. Reducing extent\\n # to 10th zero-crossing doubles maximum error.\\n fwhm = 2.0 * hwhm # full width at half maximum\\n rperfw = 0.26525 # radians per fwhm of sinc\\n xrange = 20 * np.pi # 20th zero of sinc (radians)\\n wrange = xrange * fwhm * rperfw # 20th zero of sinc (wavelength)\\n nhalf = int(wrange / dw + 0.999) ## points in half sinc\\n nsinc = 2 * nhalf + 1 ## points in sinc (odd!)\\n wsinc = (np.arange(nsinc, dtype=float) - nhalf) * dw # absissca (wavelength)\\n xsinc = wsinc / (fwhm * rperfw) # absissca (radians)\\n xsinc[nhalf] = 1.0 # avoid divide by zero\\n sinc = np.sin(xsinc) / xsinc # calculate sinc\\n sinc[nhalf] = 1.0 # insert midpoint\\n xsinc[nhalf] = 0.0 # fix xsinc\\n sinc = sinc / np.sum(sinc) # normalize sinc\\n\\n # Pad spectrum ends to minimize impact of Fourier ringing.\\n sout = convolve(s, sinc, mode=\\\"nearest\\\")\\n\\n return sout\",\n \"def sin(data):\\n return _make.sin(data)\",\n \"def oscillator(freq: float, sec: float, rate: int = 441000):\\n phases = np.cumsum(2.0 * np.pi * freq / rate * np.ones(int(rate * sec)))\\n return np.sin(phases)\",\n \"def line_sSFR(**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n GR = glo.global_results()\\n \\n L_line = getattr(GR,'L_'+p.line+'_sun')#[0:100]\\n SFR = getattr(GR,'SFR')#[0:100]\\n Zsfr = getattr(GR,'Zsfr')#[0:100]\\n R_gas = getattr(GR,'R2_gas')#[0:100]\\n M_H2 = getattr(GR,'M_H2_R2_gas')#[0:100]\\n M_star = getattr(GR,'M_star')#[0:100]\\n\\n # Take only MS galaxies?\\n if p.select == '_MS':\\n indices = aux.select_salim18(GR.M_star,GR.SFR)\\n L_line = L_line[indices]\\n SFR = SFR[indices]\\n Zsfr = Zsfr[indices]\\n print('With MS selection criteria: only %i galaxies' % (len(L_line)))\\n\\n SFR = SFR[L_line > 0]\\n Zsfr = Zsfr[L_line > 0]\\n R_gas = R_gas[L_line > 0]\\n M_H2 = M_H2[L_line > 0]\\n M_star = M_star[L_line > 0]\\n sSFR = SFR/M_star\\n L_line = L_line[L_line > 0]\\n\\n print('%i data points ' % (len(L_line)))\\n\\n labs = {'_M10':'Mach=10 power-law',\\\\\\n '_arepoPDF_dim':'AREPO parametric PDF with extinction',\\\\\\n '_arepoPDF':'AREPO parametric PDF'}\\n lab = labs[p.table_ext]\\n\\n if p.add:\\n ax = p.ax\\n else:\\n fig,ax = plt.subplots(figsize=(8,6))\\n\\n if p.select == 'Sigma_M_H2':\\n Sigma_M_H2 = M_H2/(np.pi*R_gas**2)\\n m = ax.scatter(sSFR[np.argsort(Sigma_M_H2)],L_line[np.argsort(Sigma_M_H2)],marker='o',s=20,\\\\\\n c=np.log10(Sigma_M_H2[np.argsort(Sigma_M_H2)]),vmin=3.5,label=lab,alpha=0.6,zorder=10)\\n cbar = plt.colorbar(m,ax=ax)\\n cbar.set_label(label=r'log $\\\\Sigma_{H2}$ [M$_{\\\\odot}$/kpc$^2$]',size=15)\\n else:\\n m = ax.scatter(sSFR,L_line,marker='o',s=20,\\\\\\n c=Zsfr,label=lab,alpha=0.6,zorder=10)\\n cbar = plt.colorbar(m,ax=ax)\\n cbar.set_label(label=r'$\\\\langle Z\\\\rangle_{\\\\mathrm{SFR}}$ [Z$_{\\\\odot}$]',size=15)\\n\\n if p.add_obs:\\n add_line_sSFR_obs(p.line,L_line,ax,select=p.select)\\n\\n ax.set_xscale('log')\\n ax.set_yscale('log')\\n ax.set_xlabel(getlabel('sSFR'))\\n ax.set_ylabel(getlabel(p.line))\\n handles,labels = ax.get_legend_handles_labels()\\n handles = np.flip(handles)\\n labels = np.flip(labels)\\n # ax.legend(handles,labels,loc='upper left',fontsize=7)\\n ax.legend(handles,labels,loc='lower right',fontsize=7,frameon=True,framealpha=0.5) \\n print(np.min(sSFR),np.max(sSFR))\\n if not p.xlim: p.xlim = 10.**np.array([-13,-7])\\n if not p.ylim: \\n p.ylim = [np.median(L_line)/1e6,np.median(L_line)*1e4]\\n ax.set_xlim(p.xlim)\\n ax.set_ylim(p.ylim)\\n ax.grid(ls='--')\\n\\n if p.savefig & (not p.add):\\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \\n plt.savefig(p.d_plot + 'luminosity/%s_sSFR.png' % p.line, format='png', dpi=300)\",\n \"def flatNoisePellicle():\\n #Get data\\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/' \\\\\\n 'NoiseStudy/SolarBwPellicle/'\\n d1,dx1 = met.read4DFits(wdir+'161209_Avg8_Meas1.fits')\\n d2,dx2 = met.read4DFits(wdir+'161209_Avg8_Meas2.fits')\\n d3,dx3 = met.read4DFits(wdir+'161209_Avg8_Meas3.fits')\\n d4,dx4 = met.read4DFits(wdir+'161209_Avg8_Meas4.fits')\\n\\n #Construct power spectra\\n f12,pow12 = fourier.meanPSD((d1-d2)[:,100:-100],\\\\\\n win=np.hanning,dx=dx1,irregular=True)\\n f23,pow23 = fourier.meanPSD((d2-d3)[:,100:-100],\\\\\\n win=np.hanning,dx=dx1,irregular=True)\\n f34,pow34 = fourier.meanPSD((d3-d4)[:,100:-100],\\\\\\n win=np.hanning,dx=dx1,irregular=True)\\n f14,pow14 = fourier.meanPSD((d1-d4)[:,100:-100],\\\\\\n win=np.hanning,dx=dx1,irregular=True)\\n\\n #Mid frequency\\n midfreq = [1000*np.sqrt(np.sum(p[np.logical_and(f>.1,f<1.)])) \\\\\\n for f,p in zip([f12,f23,f34,f14],[pow12,pow23,pow34,pow14])]\\n\\n #Plot\\n plt.loglog(f12,pow12/f12[0],label='1-2: %.2f' % midfreq[0])\\n plt.loglog(f23,pow23/f23[0],label='2-3: %.2f' % midfreq[1])\\n plt.loglog(f34,pow34/f34[0],label='3-4: %.2f' % midfreq[2])\\n plt.loglog(f14,pow14/f14[0],label='1-4: %.2f' % midfreq[3])\\n plt.legend(loc='lower left')\\n plt.grid()\\n plt.title('4D Repeatability: SolarB Flat+Pellicle')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n\\n print midfreq\\n\\n return f12,pow12\",\n \"def test_double_sinusoid():\\n generator = SignalGenerator(sr=100)\\n data1 = generator.sinusoid(noise_stds=[0.1, 0.1, 0.1])\\n data2 = generator.sinusoid(dom_freqs=[0.1, 0.2, 0.3], amps=[0.1, 0.2, 0.3])\\n data = data1 + data2\\n freq_features = FrequencyFeature(data, sr=100)\\n freq_features.fft().peaks()\\n dom_freqs = freq_features.dominant_frequency(n=1)\\n dom_freqs_second = freq_features.dominant_frequency(n=2)\\n dom_freqs_third = freq_features.dominant_frequency(n=3)\\n assert np.allclose(dom_freqs, np.array([1, 2, 3]))\\n assert np.allclose(dom_freqs_second, np.array([0.1, 0.2, 0.3]))\\n assert np.allclose(dom_freqs_third, np.array([-1, -1, -1]))\",\n \"def sinh(data):\\n return _make.sinh(data)\",\n \"def one_transition_spectrum_fluor(self,tr):\\n \\n\\n ta = tr[\\\"ta\\\"] # TimeAxis\\n dd = tr[\\\"dd\\\"] # transition dipole strength\\n om = tr[\\\"om\\\"] # frequency - rwa\\n gg = tr[\\\"gg\\\"] # natural broadening (constant or time dependent)\\n fwhm = tr[\\\"fwhm\\\"] # Additional gaussian broadening of the spectra\\n sgm = fwhm/(2*numpy.sqrt(2*numpy.log(2)))\\n \\n # CD and fluorescence can be calculated in this step\\n # TODO if rotatory strength defined calculate also circular dichroism spectra\\n # TOOD calculate fluorescence spectra (for fluorescence there should be a switch because it should be calculated only for the first transition) \\n \\n \\n if self.system._has_system_bath_coupling:\\n# ct = tr[\\\"ct\\\"] # correlation function\\n re = tr[\\\"re\\\"] # reorganisation energy\\n \\n # convert correlation function to lineshape function\\n #gt = self._c2g(ta,ct.data)\\n gt = tr[\\\"gt\\\"]\\n # calculate time dependent response\\n at = numpy.exp(-numpy.conjugate(gt) -1j*om*ta.data + 2j*re*ta.data)\\n else:\\n # calculate time dependent response\\n at = numpy.exp(-1j*om*ta.data) \\n# plt.figure()\\n# plt.title(\\\"Absorption\\\")\\n# plt.plot(ta.data,numpy.real(at))\\n# plt.plot(ta.data,numpy.imag(at))\\n \\n \\n if len(gg) == 1:\\n gam = gg[0]\\n rt = numpy.exp(gam*ta.data)\\n at *= rt\\n #print(\\\"Constant: \\\", rt[20], len(at))\\n else:\\n rt = numpy.exp((gg)*ta.data) \\n at *= rt\\n #print(\\\"Time dependent: len = \\\", rt[20], len(rt))\\n \\n if fwhm!=0.0:\\n gauss = numpy.exp(-2*(numpy.pi**2)*(sgm**2)*(ta.data**2))\\n at *= gauss\\n \\n # Fourier transform the result\\n ft = dd*numpy.fft.hfft(at)*ta.step\\n ft = numpy.fft.fftshift(ft)\\n # invert the order because hfft is a transform with -i\\n ft = numpy.flipud(ft) \\n # cut the center of the spectrum\\n Nt = ta.length #len(ta.data) \\n return ft[Nt//2:Nt+Nt//2]\",\n \"def sinh(a):\",\n \"def notebook_01():\\n\\n freq_list, volt_list = las.load_freq_volt()\\n\\n n_steps, n_det, n_f, _ = np.shape(volt_list)\\n\\n #y_sym_mat_o = ds.by_sym_mat(volt_list, det_ind=0)\\n #y_sym_mat_i = ds.by_sym_mat(volt_list, det_ind=1)\\n\\n # print(np.shape(y_sym_mat_o))\\n # print(np.shape(y_sym_mat_i))\\n # (mu_o, sigma_o) = stats.norm.fit(y_sym_mat_o[:,0])\\n # (mu_i, sigma_i) = stats.norm.fit(y_sym_mat_i[:,0])\\n # print(mu_o, sigma_o)\\n # print(mu_i, sigma_i)\\n # print(mu_o*89000, mu_i*89000.0, -mu_i*89000.0, -mu_o*89000.0)\\n\\n volt_list_sym = ds.volt_list_sym_calc(volt_list)\\n\\n fit_params_mat = fp.fit_params(ff.f_b_field, volt_list_sym)\\n\\n fit_params_mat_s = fp.fit_params(ff.f_b_field_off, volt_list_sym)\\n\\n # pbd.plot_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\\n\\n # pfp.plot_fit_sym_comp(volt_list_sym, fit_params_mat, fit_params_mat_s, freq_list)\\n\\n\\n # pfp.plot_fit_sym_comp_2(volt_list_sym, fit_params_mat_s, freq_list)\\n\\n #pfp.plot_symmetry_along_z(volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\\n\\n fp.fit_params_FH_data(ff.f_b_field)\\n\\n # pbd.plot_rel_diff_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\",\n \"def Sin_Discrete(a,b,F,A = 1,f = 1):\\t\\t\\t\\t\\t\\t\\t\\t\\t# Function to generate Discrete Sinusoid\\t\\n\\ttime = np.arange(a,b,1)\\n\\tamplitude = A*np.sin(2*np.pi*time*f/F)\\n\\t\\n\\treturn amplitude,time\",\n \"def Sin_Discrete(a,b,F,A = 1,f = 1):\\t\\t\\t\\t\\t\\t\\t\\t\\t# Function to generate Discrete Sinusoid\\t\\n\\ttime = np.arange(a,b,1)\\n\\tamplitude = A*np.sin(2*np.pi*time*f/F)\\n\\t\\n\\treturn amplitude,time\",\n \"def test_FEMM_periodicity_angle():\\n\\n SPMSM_015 = load(join(DATA_DIR, \\\"Machine\\\", \\\"SPMSM_015.json\\\"))\\n\\n assert SPMSM_015.comp_periodicity() == (9, False, 9, True)\\n\\n simu = Simu1(name=\\\"test_FEMM_periodicity_angle\\\", machine=SPMSM_015)\\n\\n # Definition of the enforced output of the electrical module\\n I0_rms = 250 / sqrt(2)\\n Phi0 = 140 * pi / 180 # Maximum Torque Per Amp\\n\\n Id_ref = (I0_rms * exp(1j * Phi0)).real\\n Iq_ref = (I0_rms * exp(1j * Phi0)).imag\\n\\n simu.input = InputCurrent(\\n Id_ref=Id_ref,\\n Iq_ref=Iq_ref,\\n Na_tot=252 * 9,\\n Nt_tot=4 * 9,\\n N0=1000,\\n )\\n\\n # Definition of the magnetic simulation: with periodicity\\n simu.mag = MagFEMM(\\n type_BH_stator=1,\\n type_BH_rotor=1,\\n is_periodicity_a=True,\\n is_periodicity_t=False,\\n nb_worker=cpu_count(),\\n Kmesh_fineness=2,\\n )\\n simu.force = ForceMT()\\n\\n # Definition of the magnetic simulation: no periodicity\\n # Definition of the magnetic simulation: no periodicity\\n simu2 = simu.copy()\\n simu2.mag.is_periodicity_a = False\\n\\n simu2.force = ForceMT()\\n\\n # Run simulations\\n out = Output(simu=simu)\\n simu.run()\\n\\n out2 = Output(simu=simu2)\\n simu2.run()\\n\\n # Plot the result\\n out.mag.B.plot_2D_Data(\\n \\\"time\\\",\\n \\\"angle[0]{°}\\\",\\n data_list=[out2.mag.B],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_B_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.B.plot_2D_Data(\\n \\\"angle{°}\\\",\\n \\\"time[1]\\\",\\n data_list=[out2.mag.B],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_B_space.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.force.AGSF.plot_2D_Data(\\n \\\"wavenumber=[0,100]\\\",\\n \\\"time[0]\\\",\\n data_list=[out2.force.AGSF],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_P_space_fft.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.force.AGSF.plot_2D_Data(\\n \\\"freqs\\\",\\n \\\"angle[0]\\\",\\n data_list=[out2.force.AGSF],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_P_fft2.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.Tem.plot_2D_Data(\\n \\\"time\\\",\\n data_list=[out2.mag.Tem],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_Tem_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.Phi_wind_stator.plot_2D_Data(\\n \\\"time\\\",\\n \\\"phase\\\",\\n data_list=[out2.mag.Phi_wind_stator],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_Phi_wind_stator_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n # Compare both simu\\n Bflux = out.mag.B\\n arg_list = [\\\"angle\\\"]\\n result = Bflux.get_rphiz_along(*arg_list)\\n Brad = result[\\\"radial\\\"]\\n angle = result[\\\"angle\\\"]\\n\\n Bflux2 = out2.mag.B\\n arg_list = [\\\"angle\\\"]\\n result2 = Bflux2.get_rphiz_along(*arg_list)\\n Brad2 = result2[\\\"radial\\\"]\\n\\n assert_array_almost_equal(Brad, Brad2, decimal=1)\\n\\n return out, out2\",\n \"def test_synth_simple():\\n \\n twd = tempfile.mkdtemp(dir=os.getcwd()+\\\"/tmp\\\")\\n print(twd)\\n \\n wmin, wmax, dwl = 6700, 6720, 0.01\\n ll = turbopy.TSLineList(os.path.join(data_path, \\\"vald-6700-6720.list\\\"))\\n atmo = turbopy.MARCSModel.load(os.path.join(data_path, \\\"sun.mod\\\"))\\n atmo.Teff = 5777\\n atmo.logg = 4.44\\n atmo.MH = 0.0\\n atmo.AM = 0.0\\n wave, norm, flux = turbopy.run_synth(wmin, wmax, dwl,\\n atmosphere=atmo, vt=1.0,\\n linelist=ll, twd=twd)\\n \\n wave2, norm2, flux2 = turbopy.run_synth(wmin, wmax, dwl,\\n [12.0, 0.4], [6.0, 1.0], [8.0, 1.0],\\n atmosphere=atmo, vt=1.0,\\n linelist=ll, twd=twd)\\n \\\"\\\"\\\"\\n import matplotlib.pyplot as plt\\n fig = plt.figure()\\n plt.plot(wave, norm, 'k-', lw=3)\\n plt.plot(wave, norm2, 'r-', lw=1)\\n fig.savefig(\\\"test3.pdf\\\")\\n plt.close(fig)\\n \\\"\\\"\\\"\",\n \"def find_signal_morphology(rr_intervals, fs: float = 4):\\n baseline = calculate_time_features(rr_intervals=rr_intervals)['baseline']\\n vhr = rr_intervals - baseline\\n accel_values = np.sort(vhr[vhr > 15]) # Change for right value\\n decel_values = np.sort(vhr[vhr < -15]) # Change for right value\\n accel_args = np.zeros(accel_values.shape, dtype=int)\\n decel_args = np.zeros(decel_values.shape, dtype=int)\\n acceleration_array = []\\n deceleration_array = []\\n k = 0\\n for i, x in enumerate(vhr):\\n if x in accel_values:\\n accel_args[k] = int(i)\\n k += 1\\n # Make acceleration array of tuples (start, end)\\n if np.sum(accel_values > 0):\\n start = accel_args[0]\\n end = accel_args[0]\\n for i in range(len(accel_args) - 1):\\n if (accel_args[i + 1] - accel_args[i] >= 2) or (i + 1 == len(accel_args) - 1):\\n acceleration_array.append((start, end))\\n start = accel_args[i + 1]\\n else:\\n end = accel_args[i + 1]\\n # Make deceleration array of tuples (start, end)\\n k = 0\\n for i, x in enumerate(vhr):\\n if x in decel_values:\\n decel_args[k] = i\\n k += 1\\n if np.sum(decel_values < 0) > 2:\\n start = decel_args[0]\\n end = decel_args[0]\\n for i in range(len(decel_args) - 1):\\n if (decel_args[i + 1] - decel_args[i] >= 2) or (i + 1 == len(decel_args)):\\n deceleration_array.append((start, end))\\n start = decel_args[i + 1]\\n else:\\n end = decel_args[i + 1]\\n delete_array = np.concatenate((accel_args, decel_args))\\n vhr_pure = np.delete(vhr, delete_array)\\n AmpStd = np.sqrt(np.mean(np.square(vhr_pure)))\\n return baseline, AmpStd, acceleration_array, deceleration_array\",\n \"def create_sinus_plus_stochastic_noise_scenario(missing_percentage, periodparameter, scenario_name):\\n # The stockprice is a brownian motion 7 days a week all year. \\n total_days = 1460\\n noise = s.gen_normal(1460)\\n days = np.arange(total_days)\\n sinus = np.sin(days/periodparameter)\\n noisy_sin = sinus+0.15*noise\\n\\n # The sp_no_missing_values will take the allyear stockprice and remove the weekends + 7 days a year random holidays.\\n sin_missing_values = copy.deepcopy(noisy_sin)\\n\\n missing_counter = 0\\n\\n while(missing_counter < missing_percentage*(total_days)):\\n randomday = random.randint(0, total_days)\\n if(sin_missing_values[randomday] != np.nan):\\n sin_missing_values[randomday] = np.nan\\n missing_counter = missing_counter + 1\\n\\n plt.figure(figsize=(9,4))\\n plt.plot(sin_missing_values)\\n plt.legend([scenario_name],\\n loc='upper left')\\n plt.show()\\n\\n \\n dict = {'noisy_sin': noisy_sin, 'noisy_sin_missing_values': sin_missing_values} \\n df = pd.DataFrame(dict)\\n output_loc = 'synthetic_data/sinus_scenarios/' + scenario_name\\n df.to_csv(output_loc)\\n return noisy_sin\",\n \"def sin(x):\\n raise NotImplementedError\",\n \"def sinh(obj):\\n\\tif isinstance(obj, Variable):\\n\\t\\tval = np.sinh(obj.val)\\n\\t\\tder = np.cosh(obj.val)\\n\\t\\tif len(obj.der.shape)>len(der.shape):\\n\\t\\t\\tder = np.expand_dims(der,1)\\n\\t\\tder = np.multiply(der, obj.der)\\n\\t\\treturn Variable(val, der)\\n\\telse:\\n\\t\\treturn np.sinh(obj)\",\n \"def bruno_mes(self):\\n MI = -125\\n MA = 125\\n INCR = 19\\n####################################################################\\n ### CHANNEL 1\\n self.write('CHN 1')\\n self.write('CHN?')\\n print 'Acting on channel:',self.read()\\n self.write('WAVE ARB')\\n self.write('ARBLOAD ARB1')\\n self.write('FREQ 100')\\n self.write('DCOFFS 0.05')\\n self.write('AMPL 0.1')\\n \\n l =(125,-125,125)#arange(MI,MA,INCR) # the ramp\\n# lll = copy(l)[::-1][1:-1]\\n# l = concatenate((l,lll))\\n self.write_array_to_byte(l,1)\",\n \"def flatNoiseCGH():\\n #Get data\\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/NoiseStudy/FlatMeasurements/'\\n d1,dx1 = met.read4DFits(wdir+'161205_RefFlat_Avg8_Meas1.fits')\\n d2,dx2 = met.read4DFits(wdir+'161205_RefFlat_Avg8_Meas2.fits')\\n p1,px1 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestPitch_Meas1.fits')\\n p2,px2 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestPitch_Meas2.fits')\\n p3,px3 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestRoll_Meas1.fits')\\n p4,px4 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestRoll_Meas2.fits')\\n\\n #Construct baseline power spectra\\n f1,pow1 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1)\\n f2,pow2 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1,axis=1)\\n \\n #Construct parroted power spectra\\n f3,pow3 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx1)\\n f4,pow4 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx2,axis=1)\\n f5,pow5 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx1)\\n f6,pow6 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx2,axis=1)\\n\\n #Plot\\n plt.loglog(f1,pow1/f1[0],label='Axial Baseline')\\n plt.loglog(f2,pow2/f2[0],label='Azimuthal Baseline')\\n plt.loglog(f3,pow3/f3[0],label='Pitch Axial')\\n plt.loglog(f4,pow4/f4[0],label='Pitch Azimuthal')\\n plt.loglog(f5,pow5/f5[0],label='Roll Axial')\\n plt.loglog(f6,pow6/f6[0],label='Roll Azimuthal')\\n plt.title('Residual Fringe Repeatability Impact')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n plt.legend(loc='lower left')\\n\\n return f1,pow1\",\n \"def build_oblique_foF2_observed_by_radar(rad=\\\"cvw\\\", dates=[dt.datetime(2017,8,21), dt.datetime(2017,8,21)], bmnum=11, scan_num=1,\\n remove_first_range=800, remove_last_range=2500, power_drop=10., plot=True):\\n csv_fname = \\\"data/{rad}_{start}_{end}.csv\\\".format(rad=rad, start=dates[0].strftime(\\\"%Y.%m.%d.%H.%M\\\"), \\n end=dates[1].strftime(\\\"%Y.%m.%d.%H.%M\\\"))\\n if not os.path.exists(csv_fname):\\n fdata = FetchData( rad, [dates[0], dates[1]] )\\n s_params = [\\\"noise.sky\\\", \\\"tfreq\\\", \\\"frang\\\", \\\"rsep\\\", \\\"scan\\\", \\\"bmnum\\\"]\\n v_params = [\\\"slist\\\", \\\"v\\\", \\\"w_l\\\", \\\"p_l\\\", \\\"elv\\\"]\\n _, scans = fdata.fetch_data(by=\\\"scan\\\", s_params=s_params, v_params=v_params)\\n beams = []\\n # Resacle tx_frequency and estimate slant range \\n for scan in scans:\\n for beam in scan.beams:\\n if len(beam.slist) > 0:\\n setattr(beam, \\\"slant_range\\\", beam.frang + np.array(beam.slist.tolist()) * beam.rsep)\\n setattr(beam, \\\"tfreq\\\", np.round(beam.tfreq/1e3,1))\\n beams.append(beam)\\n # Extract oblique foF2 or MUF scan by scan\\n print(\\\"\\\\n Data will be averaged over {} scans\\\".format(scan_num))\\n print(\\\" Processing beam {}\\\".format(bmnum))\\n print(\\\" Remove first range {}\\\".format(remove_first_range))\\n print(\\\" Remove last range {}\\\".format(remove_last_range))\\n print(\\\" Power drop {}\\\".format(power_drop))\\n skip_distance, o_foF2, time_start, time_end = [], [], [], []\\n for i in range(len(scans)-scan_num):\\n rscan = scans[i:i+scan_num]\\n p_l, srange, tfrq, angle = [], [], [], []\\n for scan in rscan:\\n for beam in scan.beams:\\n if beam.bmnum == bmnum:\\n if len(beam.slist) > 0:\\n p_l.extend(beam.p_l.tolist())\\n srange.extend(beam.slant_range.tolist())\\n tfrq.append(beam.tfreq)\\n if type(beam.elv) is list: angle.extend(beam.elv)\\n else: angle.extend(beam.elv.tolist())\\n du = pd.DataFrame()\\n du[\\\"p_l\\\"], du[\\\"srange\\\"] = p_l, srange\\n du = du[(du.srange>remove_first_range) & (du.srange<remove_last_range)]\\n fname = \\\"images/{}.png\\\".format(rscan[0].stime.strftime(\\\"%Y-%m-%d-%H-%M\\\"))\\n if len(du) > 0:\\n sd = fit_lambda(du, power_drop, tfreq=np.mean(tfrq), elv=np.mean(angle).round(1), \\n xlabel=\\\"srange\\\", ylabel=\\\"p_l\\\", fname=fname, plot=plot)\\n if sd != np.nan:\\n skip_distance.append(sd)\\n o_foF2.append(np.mean(tfrq))\\n time_start.append(rscan[0].stime)\\n time_end.append(rscan[-1].stime)\\n df = pd.DataFrame()\\n df[\\\"skip_distance\\\"], df[\\\"o_foF2\\\"], df[\\\"time_start\\\"], df[\\\"time_end\\\"] = skip_distance, o_foF2, time_start, time_end\\n df.to_csv(csv_fname, index=False, header=True)\\n else: df = pd.read_csv(csv_fname, parse_dates=[\\\"time_start\\\", \\\"time_end\\\"])\\n print(\\\" Header:\\\\n\\\",df.head())\\n return df\",\n \"def OxygenTransmission(T,P,n_wv,wavelength,dr,freq_lim=np.array([lp.c/770e-9,lp.c/768e-9]),sim_nu=np.array([]),spec_file=''):\\n # fraction of O2 by number density\\n fO2 = (32*0.2320+28.02*0.7547+44.01*0.00046+39.94*0.0128+20.18*0.000012+4.0*0.0000007+83.8*0.000003+131.29*0.00004)*0.2320/32.0\\n \\n if len(spec_file) == 0:\\n spec_file = '/Users/mhayman/Documents/DIAL/O2_HITRAN2012_760_781.txt'\\n \\n if sim_nu.size==0:\\n sim_nu = np.arange(-3e9,3e9,20e6)\\n \\n# inu0 = np.argmin(np.abs(sim_nu)) # index to center of frequency array\\n \\n n_o2=fO2*(P/(lp.kB*T)-n_wv) # to convert atm to Pa use *101325\\n ext_o2 = rb.ExtinctionFromHITRAN(lp.c/wavelength+sim_nu,T,P,(mO2*1e-3)/lp.N_A,nuLim=freq_lim,freqnorm=True,filename=spec_file).T\\n T_o2 = np.exp(-np.cumsum(n_o2[np.newaxis,:]*ext_o2,axis=1)*dr)\\n \\n return T_o2,sim_nu\",\n \"def f_sin(k):\\n return k * pk(k, suppression)\",\n \"def spectrum(datapath, run, forcebins = False):\\n runpath = datapath + '/' + run\\n events = [evnt for evnt in listdir(runpath) if not isfile(join(runpath,evnt))]\\n allTraces = []\\n total_time = 0\\n pulses = {'zero': [], 'one': [], 'two': [], 'three': [], 'other': []}\\n times = {'zero': [], 'one': [], 'two': [], 'three': [], 'other': []}\\n #camextratime = 25e-6\\n for event in events:\\n if int(event)> 3:\\n break\\n print(event)\\n e = sbc.DataHandling.GetSBCEvent.GetEvent(runpath,event)\\n if e[\\\"slowDAQ\\\"][\\\"loaded\\\"]:\\n #print(e[\\\"fastDAQ\\\"].keys())\\n cgate = e[\\\"fastDAQ\\\"][\\\"CAMgate\\\"]\\n #dcam = np.diff(cgate)\\n fdt = e['fastDAQ']['time']\\n #camOffTimes = np.sort(np.array([fdt[i] for i in range(len(dcam)) if dcam[i] > 0.5]))\\n \\n #camOnTimes = np.sort(np.array([fdt[i] for i in range(len(dcam)) if dcam[i] < 0.5]))\\n fddt = fdt[1]-fdt[0]\\n tfast = fdt[-1]-fdt[0]\\n LED_on = [fdt[i] for i in range(len(cgate)) if cgate[i]<-0.5]\\n blockedFraction = ((len(LED_on)*fddt))/tfast\\n print(blockedFraction)\\n tr = e[\\\"PMTtraces\\\"]\\n trac = tr[\\\"traces\\\"]\\n dt = tr[\\\"dt\\\"]\\n #event_time = (tr['t0_sec'][-1]+tr['t0_frac'][-1]-tr['t0_sec'][0] - tr['t0_frac'][0])[0]\\n event_time = (((e[\\\"slowDAQ\\\"][\\\"elapsed_time\\\"][-1]-e[\\\"slowDAQ\\\"][\\\"elapsed_time\\\"][0]))*(1-blockedFraction))\\n #print(event_time)\\n total_time += event_time\\n\\n #f,axes = plt.subplots(1,5,sharey=True)\\n #f.suptitle(runpath+\\\"/\\\"+str(event))\\n #pmttracetime = e[\\\"PMTtraces\\\"][\\\"t0_sec\\\"][:,0]+e[\\\"PMTtraces\\\"][\\\"t0_frac\\\"][:,0]\\n #d=sbc.AnalysisModules.PMTfastDAQalignment.PMTandFastDAQalignment(e)\\n #pmtalign = d[\\\"PMT_trigt0_sec\\\"]+d[\\\"PMT_trigt0_frac\\\"]\\n #tracetimes = pmttracetime - pmtalign\\n #camoffindex = 0\\n #camonindex = 0\\n for i in range(len(trac)):\\n #print(i)\\n \\\"\\\"\\\"\\n thistracetime = tracetimes[i]\\n \\n #nearestcamoff = min(camOffTimes, key=lambda x:abs(x-thistracetime))\\n #nearestcamon = min(camOnTimes, key=lambda x:abs(x-thistracetime))\\n print(camOffTimes[camoffindex])\\n print(thistracetime)\\n if thistracetime > camOffTimes[camoffindex]:\\n camoffindex += 1\\n if thistracetime > camOnTimes[camonindex]:\\n camonindex += 1 \\n if camoffindex<len(camOffTimes)-1:\\n if abs(camOffTimes[camoffindex]-thistracetime)<camextratime:\\n print('excluding a trace near a camera off')\\n continue\\n if camonindex<len(camOnTimes)-1:\\n if abs(camOnTimes[camonindex]-thistracetime)<camextratime:\\n print('excluding a trace near a camera on')\\n continue\\n \\\"\\\"\\\"\\n trace = np.fabs(trac[i][0])\\n if max(trace) == 128:\\n trace = stitchTraces(trace,np.fabs(e[\\\"PMTtraces\\\"][\\\"traces\\\"][i][1]))\\n dt_tr = dt[i][0]\\n\\n # populate dictionaries arrays based on how many pulses there were\\n [a,n,totInt,pktimes] = SBC_pulse_integrator_bressler(trace,dt_tr)\\n if n == 0:\\n number = 'zero'\\n allTraces.append(a)\\n elif n == 1:\\n number = 'one'\\n allTraces.append(a)\\n times['one'].append(pktimes[0])\\n elif n == 2:\\n number = 'two'\\n allTraces.append(a)\\n elif n == 3:\\n number = 'three'\\n allTraces.append(a)\\n else:\\n number = 'other'\\n allTraces.append(a)\\n \\\"\\\"\\\"\\n #if a != None:\\n if isZero:\\n if j < 5:\\n if isNegative:\\n if random() >0:\\n print(runpath+\\\"/\\\"+str(event)+\\\" pmt trace \\\"+str(i))\\n tPMT = np.arange(len(trace))*dt_tr\\n axes[j].plot(tPMT,trace,lw=3)\\n axes[j].set_xlabel(\\\"time (s)\\\",fontsize=25)\\n axes[j].set_ylabel(\\\"PMT response (ADC)\\\",fontsize=25)\\n j+=1\\n \\n \\n plt.show\\n \\\"\\\"\\\"\\n pulses[number].append(a)\\n gc.collect()\\n \\n \\n for k in pulses:\\n pulses[k] = [x for x in pulses[k] if x != None]\\n \\n allTraces = [x for x in allTraces if x != None]\\n \\n plt.figure()\\n\\n Nbins = int(np.floor(np.sqrt(len(allTraces))))\\n allvals, bins, _ = plt.hist(allTraces,Nbins,label='all traces')\\n \\n areaVals = {'zero': [], 'one': [], 'two': [], 'three': [], 'other': []}\\n for k in pulses:\\n if k != 'other':\\n areaVals[k], _, _ = plt.hist(pulses[k],bins,histtype = 'step',\\n linewidth = 3,label= k+' hits')\\n plt.legend(fontsize=12)\\n plt.show() \\n #spe_spectrum = areaVals['one']\\n \\n #def gaussian(x,mu,sigma,amplitude):\\n # return amplitude * np.exp(-((x - mu) /(np.sqrt(2)* sigma))**2 )\\n \\n #params_spe, params_cov_spe = scipy.optimize.curve_fit(gaussian,bins[:len(areaVals['one'])],\\n # spe_spectrum,\\n # p0=[0.4e8,1e7,40])\\n #params_twohits, params_cov_twohits = scipy.optimize.curve_fit(gaussian,\\n # bins[:len(areaVals['two'])],\\n # areaVals['two'],\\n # p0=[0.8e8,1e7,10])\\n #mu_spe = params_spe[0]\\n #mu_2 = params_twohits[0] - mu_spe\\n #print(mu_spe)\\n #print(mu_2)\\n \\n #mu_avg = (mu_spe + mu_2)*0.5\\n #mu_avg = get_gain(datapath,run)\\n mu_avg = 1e7\\n print(mu_avg)\\n\\n \\n plt.figure()\\n plt.grid(True)\\n if isinstance(forcebins,np.ndarray):\\n bins=forcebins\\n fullspect,_,_=plt.hist([t/mu_avg for t in allTraces],\\n forcebins,label='all traces')\\n \\n else:\\n fullspect,bins,_=plt.hist([t/mu_avg for t in allTraces],\\n int(np.floor(np.sqrt(len(allTraces)))),label='all traces')\\n \\n #print(bins)\\n plt.yscale('log')\\n plt.xlabel('phe based on a gain of '+str(mu_avg)+' electrons per phe')\\n plt.legend()\\n plt.show\\n print(sum(fullspect)/total_time)\\n print(\\\"The Total Exposure Time of run \\\"+str(runpath)+ \\\" was \\\"+str(total_time)+\\\" Seconds\\\")\\n print(\\\"The overall PMT trigger rate was \\\" + str(len(allTraces)/total_time)+ \\\"Hz\\\")\\n return [fullspect,bins,total_time]\",\n \"def sinwave(scene):\\n # create an empty homogeneous transformation\\n matrix = np.eye(4)\\n # set Y as cos of time\\n matrix[1][3] = np.cos(time.time()) * 2\\n # set Z as sin of time\\n matrix[2][3] = np.sin(time.time()) * 3\\n\\n # take one of the two spheres arbitrarily\\n node = s.graph.nodes_geometry[0]\\n # apply the transform to the node\\n scene.graph.update(node, matrix=matrix)\",\n \"def sin(fs: float, Ns: int, Ss: int) -> np.ndarray:\\n t = np.arange(Ns)\\n omega = 2 * np.pi * fs / Ss\\n return np.sin(omega * t)\",\n \"def test_atm_psf_fft(self):\\n config = {\\n 'psf': {\\n 'type': 'AtmosphericPSF'\\n },\\n 'gal': {\\n 'type': 'DeltaFunction',\\n 'flux': 1e5,\\n 'sed': {\\n 'file_name': 'vega.txt',\\n 'wave_type': 'nm',\\n 'flux_type': 'fnu',\\n },\\n },\\n 'input': {\\n 'atm_psf': {\\n 'airmass': self.opsim_data['airmass'],\\n 'rawSeeing': self.opsim_data['rawSeeing'],\\n 'band': self.opsim_data['band'],\\n 'screen_size': 409.6,\\n 'boresight': {\\n 'type': 'RADec',\\n 'ra': { 'type': 'Degrees', 'theta': self.opsim_data['rightascension'], },\\n 'dec': { 'type': 'Degrees', 'theta': self.opsim_data['declination'], }\\n }\\n }\\n },\\n 'stamp': {\\n 'type': 'LSST_Silicon',\\n\\n 'fft_sb_thresh': 2.e5, # When to switch to fft and a simpler PSF and skip silicon\\n 'max_flux_simple': 100, # When to switch to simple SED\\n\\n # rawSeeing is a bit big, so need this one to get the right size stamp.\\n # But others (airmass, band) may be omitted in this case.\\n # Also, don't need det_num since not doing vignetting.\\n 'rawSeeing': self.opsim_data['rawSeeing'],\\n 'image_pos': {\\n 'type': 'XY',\\n 'x': 0,\\n 'y': 0,\\n }\\n },\\n 'image' : {\\n 'size': 64,\\n 'random_seed': 1234,\\n 'wcs': {\\n 'type' : 'Tan',\\n 'dudx' : 0.2,\\n 'dudy' : 0.,\\n 'dvdx' : 0.,\\n 'dvdy' : 0.2,\\n 'ra' : '@input.atm_psf.boresight.ra',\\n 'dec' : '@input.atm_psf.boresight.dec',\\n },\\n 'bandpass': {\\n 'file_name': 'LSST_r.dat',\\n 'wave_type': 'nm',\\n 'thin': 1.e-4,\\n },\\n 'noise': {'type': 'Poisson'},\\n }\\n }\\n\\n # First make a reference image, using photon shooting\\n config1 = galsim.config.CopyConfig(config)\\n ref_img = galsim.config.BuildImage(config1)\\n\\n # Repeat with an object bright enough to switch to FFT\\n config['gal']['flux'] = 1.e8\\n with CaptureLog() as cl:\\n img = galsim.config.BuildImage(config, logger=cl.logger)\\n #print(cl.output)\\n assert 'Check if we should switch to FFT' in cl.output\\n assert 'Yes. Use FFT for this object.' in cl.output\\n\\n print('Peak of reference PSF (flux=1.e5): ',ref_img.array.max())\\n print('Peak of FFT PSF (flux=1.e8): ',img.array.max())\\n print('FWHM of reference PSF: ',ref_img.view(scale=0.2).calculateFWHM())\\n print('FWHM of FFT PSF: ',img.view(scale=0.2).calculateFWHM())\\n print('Rmom of reference PSF: ',ref_img.view(scale=0.2).calculateMomentRadius())\\n print('Rmom of FFT PSF: ',img.view(scale=0.2).calculateMomentRadius())\\n\\n # The FFT image is about 10^3 x brighter than the reference image.\\n # Scale it down to make it easier to compare to the reference image.\\n img /= 1.e3\\n\\n # Peaks should now be similar\\n np.testing.assert_allclose(ref_img.array.max(), img.array.max(), rtol=0.05)\\n\\n # The sizes should also be pretty close\\n np.testing.assert_allclose(ref_img.view(scale=0.2).calculateFWHM(),\\n img.view(scale=0.2).calculateFWHM(), rtol=0.05)\\n np.testing.assert_allclose(ref_img.view(scale=0.2).calculateMomentRadius(),\\n img.view(scale=0.2).calculateMomentRadius(), rtol=0.1)\\n\\n # Inded the whole image should be similar, but this is pretty noisy,\\n # so we need some loose tolerances for this one.\\n np.testing.assert_allclose(ref_img.array, img.array, rtol=0.15, atol=50)\",\n \"def test_sinePSD(self):\\n data = _load_mtdata('PASC.dat.gz')\\n # Calculate the spectra.\\n spec, freq = sine_psd(data, 1.0)\\n # No NaNs are supposed to be in the output.\\n self.assertEqual(np.isnan(spec).any(), False)\\n self.assertEqual(np.isnan(freq).any(), False)\\n # Load the good data.\\n datafile = os.path.join(os.path.dirname(__file__), 'data',\\n 'sine_psd.npz')\\n spec2 = np.load(datafile)['spec']\\n freq2 = np.arange(43201) * 1.15740741e-05\\n # Compare.\\n np.testing.assert_almost_equal(freq, freq2)\\n np.testing.assert_almost_equal(spec / spec, spec2 / spec, 2)\",\n \"def inst_bp(instrument,array=\\\"2\\\"):\\n\\n if instrument == \\\"MUSTANG2\\\" or instrument == \\\"MUSTANG\\\":\\n srms = (300*u.um).to(\\\"m\\\") # surface RMS (microns)\\n ### Reference: https://science.nrao.edu/facilities/gbt/proposing/GBTpg.pdf\\n EA90 = 0.36 # Aperture efficiency at 90 GHz\\n ### The beam efficiencies should be taken as 1.37* Aperture Efficiency\\n R90 = np.exp(-4.0*np.pi*(srms/(const.c/(9.0e10*u.s**-1))).value) #\\n Gnot = EA90/R90 # Unphysical, but see documentation...\\n if instrument == \\\"MUSTANG2\\\":\\n flow = 75.0 # GHz\\n fhig = 105.0 # GHz\\n else:\\n flow = 82.5 # GHz\\n fhig = 97.5 # GHz\\n \\n farr = np.arange(flow,fhig,1.0) # frequency array.\\n tran = farr*0.0 + 1.0 # Let the transmission be unity everywhere.\\n Larr = const.c.value/(farr*1.0e9) # Keep calm and carry on.\\n ### Old formula:\\n #Ruze = Gnot * np.exp(-4.0*np.pi*(srms.value)/Larr)\\n ### Correct formula: (10 April 2018)\\n Ruze = Gnot * np.exp(-(4.0*np.pi*srms.value/Larr)**2)\\n NRuz = Ruze / np.max(Ruze) # Normalize it\\n band = tran * Ruze # Bandpass, with (unnormalized) Ruze efficiency\\n \\n if instrument == \\\"NIKA2\\\" or instrument == \\\"NIKA\\\":\\n caldir='/home/romero/NIKA2/NIKA_SVN/Processing/Pipeline/Calibration/BP/'\\n bpfile=caldir+'Transmission_2017_Jan_NIKA2_v1.fits'\\n hdulist = fits.open(bpfile)\\n\\n if array == \\\"1H\\\": # 1mm (260 GHz) array, Horizontal Polarization\\n tbdata = hdulist[1].data # 1H\\n freq = tbdata.field(0)\\n tran = tbdata.field(1)\\n erro = tbdata.field(2)\\n atmt = tbdata.field(3)\\n cfreq1h = np.sum(freq*tran)/np.sum(tran)\\n \\n if array == \\\"1V\\\": # 1mm (260 GHz) array, Vertical Polarization\\n tbdata = hdulist[2].data # 1V\\n freq = tbdata.field(0)\\n tran = tbdata.field(1)\\n erro = tbdata.field(2)\\n atmt = tbdata.field(3)\\n cfreq1v = np.sum(freq*tran)/np.sum(tran)\\n \\n if array == \\\"2\\\": # 2mm (150 GHz) array\\n tbdata = hdulist[3].data # 2\\n freq = tbdata.field(0)\\n tran = tbdata.field(1)\\n erro = tbdata.field(2)\\n atmt = tbdata.field(3)\\n cfreq2 = np.sum(freq*tran)/np.sum(tran)\\n\\n ### Trim the zero-frequency listing, if any.\\n gi=np.where(freq > 0)\\n freq = freq[gi]\\n tran = tran[gi]\\n erro = erro[gi]\\n atmt = atmt[gi]\\n \\n### Calculate Aperture efficiencies from information found at:\\n### http://www.iram.es/IRAMES/mainwiki/Iram30mEfficiencies\\n Beff = 0.630 # at 210 GHz\\n Aeff = Beff/1.27 # See text on webpage\\n srms = (66.0*u.um).to(\\\"m\\\") # surface RMS (microns)\\n R210 = np.exp(-4.0*np.pi*(srms/(const.c/(2.1e11*u.s**-1))).value) #\\n Gnot = Aeff/R210 # Unphysical, but see documentation...\\n\\n Larr = const.c.value/(freq*1.0e9) # Keep calm and carry on. \\n Ruze = Gnot * np.exp(-4.0*np.pi*(srms.value)/Larr)\\n NRuz = Ruze / np.max(Ruze) # Normalize it\\n band = tran * Ruze # Bandpass, with (unnormalized) Ruze efficiency\\n farr = freq\\n \\n#########################################################################\\n\\n if instrument == 'ACT90':\\n srms = (27.0*u.um).to(\\\"m\\\") # surface RMS (microns)\\n EA90 = 0.95 # I'm making this number up...\\n R90 = np.exp(-4.0*np.pi*(srms/(const.c/(9.0e10*u.s**-1))).value) #\\n Gnot = EA90/R90 # Unphysical, but see documentation...\\n flow = 65.0 # GHz\\n fhig = 125.0 # GHz\\n farr = np.arange(flow,fhig,1.0) # frequency array.\\n freq_ref = 90.0 # I took EA90 to be a fictitious aperature efficiency at 90 GHz\\n band = ruze_eff(farr,freq_ref,EA90,srms)\\n\\n if instrument == 'ACT150':\\n srms = (27.0*u.um).to(\\\"m\\\") # surface RMS (microns)\\n EA90 = 0.95 # I'm making this number up...\\n R90 = np.exp(-4.0*np.pi*(srms/(const.c/(9.0e10*u.s**-1))).value) #\\n Gnot = EA90/R90 # Unphysical, but see documentation...\\n flow = 120.0 # GHz\\n fhig = 180.0 # GHz\\n farr = np.arange(flow,fhig,1.0) # frequency array.\\n freq_ref = 90.0 # I took EA90 to be a fictitious aperature efficiency at 90 GHz\\n band = ruze_eff(farr,freq_ref,EA90,srms)\\n\\n\\n return band, farr\",\n \"def Char_Gate(NV,res ,B_field=400):\\n\\n\\n #data = np.loadtxt(\\\"NV_Sim_8.dat\\\") #Placeholder data to test the script\\n #NV = np.vstack((data[:,3],data[:,4]))\\n #physical constants\\n gamma_c = 1.071e3 #g-factor for C13 in Hz/G\\n #Model parameters\\n omega_larmor = 2*np.pi*gamma_c*B_field\\n tau_larmor = 2*np.pi/omega_larmor\\n tau = res[0]\\n n_pulses = int(res[1]*2) #So that we do a pi -pulse\\n\\n Ix = 0.5 * np.array([[0,1],[1,0]])\\n Iz = 0.5* np.array([[1,0],[0,-1]])\\n H0 = (omega_larmor)*Iz\\n exH0 =linalg.expm(-1j*H0*tau)\\n\\n\\n M = np.zeros(np.shape(NV)[0])\\n for idC in range(np.shape(NV)[0]):\\n A= 2*np.pi*NV[idC,0]\\n B= 2*np.pi*NV[idC,1] #Converts to radial frequency in Hz/G\\n H1 = (A+omega_larmor) *Iz +B*Ix\\n exH1 = linalg.expm(-1j*H1*tau)\\n V0 = exH0.dot(exH1.dot(exH1.dot(exH0)))\\n V1 = exH1.dot(exH0.dot(exH0.dot(exH1)))\\n n0 = Calc_axis(V0)\\n n1 =Calc_axis(V1)\\n phi = np.real(2*np.arccos(np.trace(V0)/2))\\n M[idC] = 1 - (1-np.dot(n0,n1))*np.sin(n_pulses * phi /2 )**2\\n\\n Signal = -M.prod()\\n F = (1-(Signal+1)/2)\\n return F\",\n \"def sin(x):\\n return 0.0\",\n \"def _calculate_strehl(self):\\n\\n self.strehl = np.exp(-1*((2*np.pi/self.science_wavelength)*self.high_order_wfe)**2)\",\n \"def line_SFR(**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n if p.line == 'CO(2-1)': p.select = 'Zsfr'\\n\\n GR = glo.global_results(sim_run=p.sim_run,nGal=p.nGal)\\n \\n marker = 'o'\\n if p.sim_run == p.sim_runs[0]: marker = '^'\\n\\n L_line = getattr(GR,'L_'+p.line+'_sun')#[380:400]#[0:100]\\n SFR = getattr(GR,'SFR')#[380:400]#[0:100]\\n M_star = getattr(GR,'M_star')#[380:400]#[0:100]\\n # G0_mw = getattr(GR,'F_FUV_mw')#[0:100]\\n Zsfr = getattr(GR,'Zsfr')#[380:400]#[0:100]\\n R_gas = getattr(GR,'R2_gas')#[380:400]#[0:100]\\n M_H2 = getattr(GR,'M_H2_R2_gas')#[380:400]#[0:100]\\n # if 'CO' in p.line: p.select = 'Sigma_M_H2'\\n\\n # Take only MS galaxies?\\n if p.MS == True:\\n indices = aux.select_salim18(GR.M_star,GR.SFR)\\n L_line = L_line[indices]\\n SFR = SFR[indices]\\n M_star = M_star[indices]\\n Zsfr = Zsfr[indices]\\n R_gas = R_gas[indices]\\n M_H2 = M_H2[indices]\\n print('With MS selection criteria: only %i galaxies' % (len(L_line)))\\n\\n # Just selection of galaxies\\n #SFR = SFR[0:10]\\n #Zsfr = Zsfr[0:10]\\n #R_gas = R_gas[0:10]\\n #M_H2 = M_H2[0:10]\\n #L_line = L_line[0:10]\\n #M_star = M_star[0:10]\\n\\n SFR = SFR[L_line > 0]\\n M_star = M_star[L_line > 0]\\n Zsfr = Zsfr[L_line > 0]\\n R_gas = R_gas[L_line > 0]\\n M_H2 = M_H2[L_line > 0]\\n L_line = L_line[L_line > 0]\\n print('%i data points ' % (len(L_line)))\\n\\n lSFR = np.log10(SFR)\\n lL_line = np.log10(L_line)\\n\\n\\n # plt.plot(np.log10(M_star),np.log10(SFR),'o')\\n # s = aseg\\n\\n labs = {'_100Mpc_M10':'Mach=10 power-law',\\\\\\n '_100Mpc_arepoPDF_CMZ':'SIGAME v3',\\\\\\n '_25Mpc_arepoPDF_M51':'SIGAME v3 (Simba-25)',\\\\\\n '_100Mpc_arepoPDF_M51':'SIGAME v3 (Simba-100)'}\\n lab = labs[p.sim_run+p.table_ext]\\n\\n if p.add:\\n ax = p.ax\\n else:\\n fig,ax = plt.subplots(figsize=(8,6))\\n\\n if p.select == 'Sigma_M_H2':\\n Sigma_M_H2 = M_H2/(np.pi*R_gas**2)/1e6 # per pc^-2\\n m = ax.scatter(lSFR[np.argsort(Sigma_M_H2)],lL_line[np.argsort(Sigma_M_H2)],marker=marker,s=14,\\\\\\n c=np.log10(Sigma_M_H2[np.argsort(Sigma_M_H2)]),vmin=-2.5,vmax=2.2,label=lab,alpha=0.5,zorder=10)\\n p.vmin = np.log10(Sigma_M_H2.min())\\n p.vmax = np.log10(Sigma_M_H2.max())\\n if p.cb:\\n cbar = plt.colorbar(m,ax=ax)\\n cbar.set_label(label=r'log $\\\\Sigma_{H2}$ [M$_{\\\\odot}$/pc$^2$]',size=15)\\n if p.select == 'M_star':\\n m = ax.scatter(lSFR[np.argsort(M_star)],lL_line[np.argsort(M_star)],marker=marker,s=8,\\\\\\n c=np.log10(M_star[np.argsort(M_star)]),vmin=-2.5,vmax=2.2,label=lab,alpha=0.5,zorder=10)\\n # Just one galaxy\\n # m = ax.scatter(lSFR,lL_line,marker=marker,s=15,\\\\\\n # c=np.log10(Sigma_M_H2),vmin=-2.5,vmax=2.2,label=lab,alpha=1,zorder=10)\\n if p.cb:\\n cbar = plt.colorbar(m,ax=ax)\\n cbar.set_label(label=r'log $M_{star}$ [M$_{\\\\odot}$]',size=15)\\n if p.select == 'Zsfr':\\n print('min and max Zsfr in sims: ',Zsfr.min(),Zsfr.max())\\n p.vmin = np.log10(0.01)\\n p.vmax = np.log10(3)\\n m = ax.scatter(lSFR,lL_line,marker=marker,s=20,\\\\\\n c=np.log10(Zsfr),label=lab,alpha=0.6,zorder=10,vmin=p.vmin,vmax=p.vmax)\\n if p.cb:\\n cbar = plt.colorbar(m,ax=ax)\\n cbar.set_label(label=r'log $\\\\langle Z\\\\rangle_{\\\\mathrm{SFR}}$ [Z$_{\\\\odot}$]',size=15)\\n if p.select == 'F_FUV_mw':\\n m = ax.scatter(lSFR,lL_line,marker=marker,s=20,\\\\\\n c=np.log10(G0_mw),label=lab,alpha=0.6,zorder=10)\\n if p.cb:\\n cbar = plt.colorbar(m,ax=ax)\\n cbar.set_label(label='log ' + getlabel('G0'),size=15)\\n if p.select == 'f_HII':\\n f_HII[f_HII == 0] = np.min(f_HII[f_HII > 0])\\n m = ax.scatter(lSFR[np.argsort(f_HII)],lL_line[np.argsort(f_HII)],marker=marker,s=20,\\\\\\n c=np.log10(f_HII[np.argsort(f_HII)]),label=lab,alpha=0.6,zorder=10)\\n if p.cb:\\n cbar = plt.colorbar(m,ax=ax)\\n cbar.set_label(label='log HII region fraction',size=15)\\n\\n\\n # Label galaxies?\\n # for i in range(len(SFR)):\\n # if SFR[i] > 0:\\n # ax.text(SFR[i],L_line[i],'G%i' % GR.gal_num[i],fontsize=7)\\n\\n if p.add_obs:\\n if (p.select == 'Zsfr') | (p.select == 'Sigma_M_H2'): \\n add_line_SFR_obs(p.line,L_line,ax,select=p.select,vmin=p.vmin,vmax=p.vmax)\\n else:\\n add_line_SFR_obs(p.line,L_line,ax,select=p.select)\\n\\n ax.set_xlabel('log ' + getlabel('SFR'))\\n ax.set_ylabel('log ' + getlabel(p.line))\\n handles,labels = ax.get_legend_handles_labels()\\n handles = np.flip(handles)\\n labels = np.flip(labels)\\n if ('CO' in p.line) | ('[OI]' in p.line): \\n ax.legend(handles,labels,loc='upper left',fontsize=7,frameon=True,framealpha=0.5)\\n else:\\n ax.legend(handles,labels,loc='lower right',fontsize=7,frameon=True,framealpha=0.5)\\n if not p.xlim: p.xlim = np.array([-3,4])\\n if not p.ylim: \\n p.ylim = [np.median(lL_line) - 5,np.median(lL_line) + 3]\\n if p.line == '[OI]63': p.ylim = [np.median(lL_line) - 5,np.median(lL_line) + 4]\\n if 'CO' in p.line: p.ylim = [np.median(lL_line) - 4,np.median(lL_line) + 4]\\n\\n ax.set_xlim(p.xlim)\\n ax.set_ylim(p.ylim)\\n ax.grid(ls='--')\\n\\n if p.savefig & (not p.add):\\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \\n plt.savefig(p.d_plot + 'luminosity/%s_SFR.png' % p.line, format='png', dpi=300)\",\n \"def PCO1S12Noise():\\n #Get data\\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/' \\\\\\n 'NoiseStudy/TestOptics_PCO1S12/'\\n d1,dx1 = met.read4DFits(wdir+'161202_PCO1S12_4InchCut_Avg8_Meas1.fits')\\n d2,dx2 = met.read4DFits(wdir+'161202_PCO1S12_4InchCut_Avg8_Meas2.fits')\\n d3,dx3 = met.read4DFits(wdir+'161202_PCO1S12_4InchCut_Avg8_Meas3.fits')\\n\\n #Construct power spectra\\n f12,pow12 = fourier.meanPSD((d1-d2)[:,100:-100],\\\\\\n win=np.hanning,dx=dx1,irregular=True)\\n f23,pow23 = fourier.meanPSD((d2-d3)[:,100:-100],\\\\\\n win=np.hanning,dx=dx1,irregular=True)\\n f13,pow13 = fourier.meanPSD((d1-d3)[:,100:-100],\\\\\\n win=np.hanning,dx=dx1,irregular=True)\\n\\n #Mid frequency\\n midfreq = [1000*np.sqrt(np.sum(p[np.logical_and(f>.1,f<1.)])) \\\\\\n for f,p in zip([f12,f23,f13],[pow12,pow23,pow13])]\\n\\n #Plot\\n plt.loglog(f12,pow12/f12[0],label='1-2: %.2f' % midfreq[0])\\n plt.loglog(f23,pow23/f23[0],label='2-3: %.2f' % midfreq[1])\\n plt.loglog(f13,pow13/f13[0],label='1-3: %.2f' % midfreq[2])\\n plt.legend(loc='lower left')\\n plt.grid()\\n plt.title('4D Repeatability: PCO1S12')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n\\n print midfreq\\n\\n return f12,pow12\",\n \"def Fbol_SDSSg(Teff_vec, gmag_vec):\\n Teff_vec = np.float64(Teff_vec)\\n \\n hdulist = fits.open('../Scratchwork/SDSS_filter_curves.fits')\\n data = hdulist[2].data\\n wvln = data['wavelength'] #ang\\n resp = data['respt']\\n wvln = wvln/1e4 #microns\\n minw, maxw = wvln[0], wvln[-1]\\n thru = interp1d(wvln, resp, bounds_error=False, fill_value=0.0)\\n \\n hc_k = 14388.8 #microns*K\\n hc4pi = 4.99 #10^18 J*micron\\n rad = 7.57e-16 #10^18 J micron-3 K-4\\n def g2bol_ratio(Teff):\\n plnk = lambda w: hc4pi / w**5 / (np.exp(hc_k/Teff/w) - 1.0) #J micron-4\\n total = rad*Teff**4 #J micron-3\\n part = quad(lambda w: plnk(w)*thru(w), minw, maxw)[0]\\n return part/total\\n #I checked and integrating plnk from 0 to inf gives the same as total\\n \\n g2bol_vec = np.array(map(g2bol_ratio, Teff_vec))\\n FgF0 = 10**(-2.5*gmag_vec) #ratio of flux to a reference flux of mag 0\\n FbolF0 = FgF0/g2bol_vec\\n return FbolF0\",\n \"def sin_values(period=360):\\n angles = (2 * pi * i / period for i in range(period))\\n for a in cycle(angles):\\n yield sin(a)\",\n \"def test_single_ended_ols_wls_estimate_synthetic():\\n\\n from dtscalibration import DataStore\\n import numpy as np\\n\\n np.random.seed(0)\\n\\n cable_len = 100.\\n nt = 50\\n time = np.arange(nt)\\n x = np.linspace(0., cable_len, 500)\\n ts_cold = np.ones(nt) * 4.\\n ts_warm = np.ones(nt) * 20.\\n\\n C_p = 15246\\n C_m = 2400.\\n dalpha_r = 0.0005284\\n dalpha_m = 0.0004961\\n dalpha_p = 0.0005607\\n gamma = 482.6\\n cold_mask = x < 0.5 * cable_len\\n warm_mask = np.invert(cold_mask) # == False\\n temp_real = np.ones((len(x), nt))\\n temp_real[cold_mask] *= ts_cold + 273.15\\n temp_real[warm_mask] *= ts_warm + 273.15\\n\\n st = C_p * np.exp(-dalpha_r * x[:, None]) * \\\\\\n np.exp(-dalpha_p * x[:, None]) * \\\\\\n np.exp(gamma / temp_real) / (np.exp(gamma / temp_real) - 1)\\n ast = C_m * np.exp(-dalpha_r * x[:, None]) * \\\\\\n np.exp(-dalpha_m * x[:, None]) / (np.exp(gamma / temp_real) - 1)\\n\\n print('alphaint', cable_len * (dalpha_p - dalpha_m))\\n print('alpha', dalpha_p - dalpha_m)\\n print('C', np.log(C_p / C_m))\\n print('x0', x.max())\\n\\n ds = DataStore({\\n 'st': (['x', 'time'], st),\\n 'ast': (['x', 'time'], ast),\\n 'userAcquisitionTimeFW': (['time'], np.ones(nt)),\\n 'cold': (['time'], ts_cold),\\n 'warm': (['time'], ts_warm)\\n },\\n coords={\\n 'x': x,\\n 'time': time},\\n attrs={\\n 'isDoubleEnded': '0'})\\n\\n sections = {\\n 'cold': [slice(0., 0.5 * cable_len)],\\n 'warm': [slice(0.5 * cable_len, cable_len)]}\\n\\n # OLS\\n ds.calibration_single_ended(sections=sections,\\n st_label='st',\\n ast_label='ast',\\n method='ols',\\n solver='sparse')\\n\\n np.testing.assert_almost_equal(\\n ds.gamma.values, gamma, decimal=6)\\n np.testing.assert_almost_equal(\\n ds.dalpha.values, dalpha_p - dalpha_m, decimal=8)\\n np.testing.assert_almost_equal(\\n ds.TMPF.values, temp_real - 273.15, decimal=4)\\n\\n # WLS\\n ds.calibration_single_ended(sections=sections,\\n st_label='st',\\n ast_label='ast',\\n st_var=1.,\\n ast_var=1.,\\n method='wls',\\n solver='sparse')\\n\\n np.testing.assert_almost_equal(\\n ds.gamma.values, gamma, decimal=6)\\n np.testing.assert_almost_equal(\\n ds.dalpha.values, dalpha_p - dalpha_m, decimal=8)\\n np.testing.assert_almost_equal(\\n ds.TMPF.values, temp_real - 273.15, decimal=4)\\n\\n pass\",\n \"def sine_wave_generator(fs, t, spl_value, freq):\\r\\n\\r\\n # \\\"Peak\\\" value in Pascals (amplitude)\\r\\n p_ref = 2e-5\\r\\n pressure_rms = p_ref * (10.00 ** (spl_value / 20.00))\\r\\n\\r\\n # Sample range\\r\\n # samples = np.linspace(0, t, int(fs * t), endpoint=False)\\r\\n time = np.arange(0, t, 1 / fs)\\r\\n\\r\\n # Theta lets you specify the sine wave value at time 0\\r\\n theta = 0\\r\\n\\r\\n # Amplitude of the signal\\r\\n amplitude = np.sqrt(2) * pressure_rms\\r\\n\\r\\n # Signal calculation\\r\\n signal = np.array(amplitude * np.sin((2.00 * math.pi * freq * time) + theta))\\r\\n\\r\\n return signal, time\",\n \"def sin(obj):\\n\\tif isinstance(obj, Variable):\\n\\t\\tval = np.sin(obj.val)\\n\\t\\tder = np.cos(obj.val)\\n\\t\\tif len(obj.der.shape)>len(der.shape):\\n\\t\\t\\tder = np.expand_dims(der,1)\\n\\t\\tder = np.multiply(der, obj.der)\\n\\t\\treturn Variable(val, der)\\n\\telse:\\n\\t\\treturn np.sin(obj)\",\n \"def syntheticSeismogram(d, rho, v, wavf, wavA=1., usingT=True, wavtyp = 'RICKER', dt=0.0001, dmax=200):\\n\\n v, rho, d = np.array(v, dtype=float), np.array(rho, dtype=float), np.array(d, dtype=float)\\n usingT = np.array(usingT, dtype=bool)\\n\\n _, t = getTimeDepth(d,v,dmax)\\n rseries,R = getReflectivity(d,rho,v)\\n\\n # time for reflectivity series\\n tref = t[1:-1]\\n\\n # create time vector\\n t = np.arange(t.min(),t.max(),dt)\\n\\n # make wavelet\\n twav = np.arange(-2.0/np.min(wavf), 2.0/np.min(wavf), dt)\\n\\n # Get source wavelet\\n wav = {'RICKER':getRicker, 'ORMSBY':getOrmsby, 'KLAUDER':getKlauder}[wavtyp](wavf,twav)\\n wav = wavA*wav\\n\\n rseriesconv = np.zeros(len(t))\\n for i in range(len(tref)):\\n index = np.abs(t - tref[i]).argmin()\\n rseriesconv[index] = rseries[i]\\n\\n # Do the convolution\\n seis = np.convolve(wav,rseriesconv)\\n tseis = np.min(twav)+dt*np.arange(len(seis))\\n index = np.logical_and(tseis >= 0, tseis <= np.max(t))\\n tseis = tseis[index]\\n seis = seis[index]\\n\\n return tseis, seis, twav, wav, tref, rseries\",\n \"def refCylNoise():\\n #Get data\\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/' \\\\\\n 'NoiseStudy/RefCylinderMeasurements/'\\n d1,dx1 = met.read4DFits(wdir+'161205_RefCylinder_Avg8_Meas1.fits')\\n d2,dx2 = met.read4DFits(wdir+'161205_RefCylinder_Avg8_Meas2.fits')\\n d3,dx3 = met.read4DFits(wdir+'161205_RefCylinder_Avg8_Meas3.fits')\\n\\n p1,px1 = met.read4DFits(wdir+'161205_RefCylinder_'\\n 'ParrotingTestPitch_Meas1.fits')\\n p2,px2 = met.read4DFits(wdir+'161205_RefCylinder_'\\n 'ParrotingTestPitch_Meas2.fits')\\n p3,px3 = met.read4DFits(wdir+'161205_RefCylinder_'\\n 'ParrotingTestRoll_Meas1.fits')\\n p4,px4 = met.read4DFits(wdir+'161205_RefCylinder_'\\n 'ParrotingTestRoll_Meas2.fits')\\n\\n #Construct baseline power spectra\\n f1,pow1 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1)\\n f2,pow2 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1,axis=1)\\n \\n #Construct parroted power spectra\\n f3,pow3 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx1)\\n f4,pow4 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx2,axis=1)\\n f5,pow5 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx1)\\n f6,pow6 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx2,axis=1)\\n\\n #Plot\\n plt.loglog(f1,pow1/f1[0],label='Axial Baseline')\\n plt.loglog(f2,pow2/f2[0],label='Azimuthal Baseline')\\n plt.loglog(f3,pow3/f3[0],label='Pitch Axial')\\n plt.loglog(f4,pow4/f4[0],label='Pitch Azimuthal')\\n plt.loglog(f5,pow5/f5[0],label='Roll Axial')\\n plt.loglog(f6,pow6/f6[0],label='Roll Azimuthal')\\n\\n return f1,pow1\",\n \"def schwefel(indiv):\\n\\ttamanho = len(indiv)\\n\\n\\ty = 418.9829 * tamanho - sum([-x * math.sin(math.sqrt(math.fabs(x))) for x in indiv])\\n\\treturn y\",\n \"def __init__(self, n): # this is equivalent to starting a random one\\n self.n = n\\n # From table S1 in the supplemental materials\\n # each c parameters is [body,limb]\\n self.cv0 = [0.3, 0.0]\\n self.cv1 = [0.2, 0.2]\\n self.cR0 = [0.196,0.131]\\n self.cR1 = [0.065,0.131]\\n #[[dbodylow,dbodyhigh],[dlimblow,dlimbhigh]]\\n self.d_params = [[1,5],[1,3]]\\n # which oscillators are limb oscillators and which ones are body oscillators is pretty constant\\n n_body = n - 4\\n self.osc_class = [0 if i < n_body else 1 for i in range(self.n)] # 0 for body oscillator, 1 for limb oscillator\\n # list of keys that can be mutated during evolution\\n self.evolvables = ['w', 'phi', 'a', 'gsl', 'gsh', 'gb1', 'gb2', 'theta', 'ampl', 'ampl_dot']\\n self.scalars = set(['gsl', 'gsh', 'gb1', 'gb2'])\\n self.nonzeros = set([int(i) for i in \\\"8 160 29 181 50 202 71 223 92 244 113 265 134 286 155 307 1 20 22 41 43 62 64 83 85 104 106 125 127 146 169 188 190 209 211 230 232 251 253 272 274 293 295 314 320 321 322 323 364 365 366 367 348 349 350 351 392 393 394 395 338 376 337 356 359 397 379 398\\\".split(\\\" \\\")])\\n self.shapes = {'w':n*n,\\n 'phi':n*n,\\n 'a':n,\\n 'theta':n,\\n 'ampl':n,\\n 'ampl_dot':n}\\n self.sizes = {'w':n*n,\\n 'phi':n*n,\\n 'a':n,\\n 'theta':n,\\n 'ampl':n,\\n 'ampl_dot':n}\",\n \"def default(N=500, p=5001, f0=(2.5,)):\\n #N = N\\n #f0=f0\\n nsamples = p\\n fsample = 400\\n\\n ripple_db = 40.0\\n cutoff_hz = 10.0\\n \\n harmonics = [Harmonic(1, 0.5, 0), \\n Harmonic(0.4, 2.5, pi/2 + 0.1),\\n Harmonic(0.2, 15.3, pi/2),\\n Harmonic(0.1, 23.45, pi/2 + 0.8)]\\n \\n t = np.arange(nsamples) / fsample\\n signal = np.zeros((N, nsamples))\\n for ampl, freq, phase in harmonics:\\n ampl = ampl*np.ones(t.shape)\\n ampl = np.tile(ampl, (N,1)) + np.outer(0.2*np.random.randint(2, size=(N,)), ampl)\\n \\n phase = phase*np.ones(t.shape)\\n phase = np.tile(phase, (N,1)) + np.outer(0.5*np.random.randint(2, size=(N,)), phase)\\n \\n x = ampl * np.cos(2*pi*freq*t + phase)\\n signal += np.random.normal(0, 0.8*ampl, (N, nsamples)) + x\\n \\n references = np.zeros((2*len(f0), nsamples))\\n for i, fx in enumerate(f0):\\n references[2*i,:] = np.cos(2*pi*fx*t)\\n references[2*i+1,:] = np.sin(2*pi*fx*t)\\n \\n nyq_rate = fsample/2.\\n width = 5. / nyq_rate\\n \\n ntaps, beta = kaiserord(ripple_db, width)\\n window = firwin(ntaps, cutoff_hz/nyq_rate, window=('kaiser', beta))\\n\\n return signal, references, window\",\n \"def one_transition_spectrum_abs(self,tr):\\n \\n\\n ta = tr[\\\"ta\\\"] # TimeAxis\\n dd = tr[\\\"dd\\\"] # transition dipole strength\\n om = tr[\\\"om\\\"] # frequency - rwa\\n gg = tr[\\\"gg\\\"] # natural broadening (constant or time dependent)\\n fwhm = tr[\\\"fwhm\\\"] # Additional gaussian broadening of the spectra\\n sgm = fwhm/(2*numpy.sqrt(2*numpy.log(2)))\\n \\n # CD and fluorescence can be calculated in this step\\n # TODO if rotatory strength defined calculate also circular dichroism spectra\\n # TOOD calculate fluorescence spectra (for fluorescence there should be a switch because it should be calculated only for the first transition) \\n \\n \\n if self.system._has_system_bath_coupling:\\n# ct = tr[\\\"ct\\\"] # correlation function\\n \\n # convert correlation function to lineshape function\\n #gt = self._c2g(ta,ct.data)\\n gt = tr[\\\"gt\\\"]\\n # calculate time dependent response\\n at = numpy.exp(-gt -1j*om*ta.data)\\n else:\\n # calculate time dependent response\\n at = numpy.exp(-1j*om*ta.data) \\n# plt.figure()\\n# plt.title(\\\"Absorption\\\")\\n# plt.plot(ta.data,numpy.real(at))\\n# plt.plot(ta.data,numpy.imag(at))\\n \\n \\n if len(gg) == 1:\\n gam = gg[0]\\n rt = numpy.exp(gam*ta.data)\\n at *= rt\\n #print(\\\"Constant: \\\", rt[20], len(at))\\n else:\\n rt = numpy.exp((gg)*ta.data) \\n at *= rt\\n #print(\\\"Time dependent: len = \\\", rt[20], len(rt))\\n \\n if fwhm!=0.0:\\n gauss = numpy.exp(-2*(numpy.pi**2)*(sgm**2)*(ta.data**2))\\n at *= gauss\\n \\n # Fourier transform the result\\n ft = dd*numpy.fft.hfft(at)*ta.step\\n ft = numpy.fft.fftshift(ft)\\n # invert the order because hfft is a transform with -i\\n ft = numpy.flipud(ft) \\n # cut the center of the spectrum\\n Nt = ta.length #len(ta.data) \\n return ft[Nt//2:Nt+Nt//2]\",\n \"def SFR_Custom(self, z):\\n a = self.customSFR[0] \\n b = self.customSFR[1] \\n c = self.customSFR[2] \\n d = self.customSFR[3] \\n SFR = a * ((1+z)**b) / (1 + ((1+z)/c)**d) * 1e9 #[1e9 for GPc-3]\\n return SFR # [Msun yr-1 Gpc-3] in comoving volume\",\n \"def sine(x, period, var):\\r\\n return var*np.sin((2*np.pi/period)*x)\",\n \"def BoatEarMoon():\\n D=1\\n alpha=math.radians(83)\\n beta=math.radians(42) \\n phi=math.radians(70) \\n mu=math.radians(10) \\n omega=math.radians(30) \\n A=25, a=12, b=20, L=0, P=0, W1=0, W2=0, N=0\\n \\n resMode()\",\n \"def sin_transition(freq1, freq2, frames, start_idx=0, samplerate=SAMPLERATE):\\n t = (start_idx + np.arange(frames)) / samplerate\\n\\n trans = (np.sin(np.pi/4*(np.linspace(0,1,frames)-0.5)*4)+1)/2 # store to not recompute each time\\n return np.sin(2 * np.pi * (freq1 + (freq2-freq1)*trans) * t).reshape(-1,1)\",\n \"def sin_transition3(freq1, freq2, frames, start_idx=0, samplerate=SAMPLERATE):\\n t = (start_idx + np.arange(frames)) / samplerate\\n t = t.reshape(-1, 1)\\n return np.sin(2 * np.pi * (freq1*(t[-1]-t)*(t[-1]-t) + freq2*(t-t[0])*(t-t[0]))/(t[-1]-t[0])/(t[-1]-t[0]) * t).reshape(-1,1)\",\n \"def test_double_ended_two_matching_sections_and_two_asym_atts():\\n from dtscalibration import DataStore\\n\\n cable_len = 100.0\\n nt = 5\\n time = np.arange(nt)\\n nx_per_sec = 4\\n nx = nx_per_sec * 9\\n x = np.linspace(0.0, cable_len, nx)\\n ts_cold = 4.0 + np.cos(time) * 4\\n ts_warm = 20.0 + -np.sin(time) * 4\\n ts_ground = np.linspace(1, 9, num=nx_per_sec)\\n\\n C_p = 1324 # 1/2 * E0 * v * K_+/lam_+^4\\n eta_pf = np.cos(time) / 10 + 1 # eta_+ (gain factor forward channel)\\n eta_pb = np.sin(time) / 10 + 1 # eta_- (gain factor backward channel)\\n C_m = 5000.0\\n eta_mf = np.cos(time + np.pi / 8) / 10 + 1\\n eta_mb = np.sin(time + np.pi / 8) / 10 + 1\\n dalpha_r = 0.005284\\n dalpha_m = 0.004961\\n dalpha_p = 0.005607\\n gamma = 482.6\\n talph_fw = 0.95\\n talph_bw = 0.85\\n\\n temp_real_kelvin = np.zeros((len(x), nt)) + 273.15\\n temp_real_kelvin[:nx_per_sec] += ts_cold[None]\\n temp_real_kelvin[nx_per_sec : 2 * nx_per_sec] += ts_warm[None]\\n temp_real_kelvin[2 * nx_per_sec : 3 * nx_per_sec] += ts_ground[:, None]\\n temp_real_kelvin[3 * nx_per_sec : 4 * nx_per_sec] += ts_ground[::-1, None]\\n temp_real_kelvin[5 * nx_per_sec : 6 * nx_per_sec] += ts_ground[:, None] + 5\\n temp_real_kelvin[6 * nx_per_sec : 7 * nx_per_sec] += ts_ground[:, None] + 5\\n temp_real_kelvin[7 * nx_per_sec : 8 * nx_per_sec] += ts_warm[None]\\n temp_real_kelvin[8 * nx_per_sec : 9 * nx_per_sec] += ts_cold[None]\\n\\n temp_real_celsius = temp_real_kelvin - 273.15\\n\\n st = (\\n eta_pf[None]\\n * C_p\\n * np.exp(-dalpha_r * x[:, None])\\n * np.exp(-dalpha_p * x[:, None])\\n * np.exp(gamma / temp_real_kelvin)\\n / (np.exp(gamma / temp_real_kelvin) - 1)\\n )\\n st[3 * nx_per_sec :] *= talph_fw\\n st[6 * nx_per_sec :] *= talph_fw\\n ast = (\\n eta_mf[None]\\n * C_m\\n * np.exp(-dalpha_r * x[:, None])\\n * np.exp(-dalpha_m * x[:, None])\\n / (np.exp(gamma / temp_real_kelvin) - 1)\\n )\\n rst = (\\n eta_pb[None]\\n * C_p\\n * np.exp(-dalpha_r * (-x[:, None] + cable_len))\\n * np.exp(-dalpha_p * (-x[:, None] + cable_len))\\n * np.exp(gamma / temp_real_kelvin)\\n / (np.exp(gamma / temp_real_kelvin) - 1)\\n )\\n rst[: 3 * nx_per_sec] *= talph_bw\\n rst[: 6 * nx_per_sec] *= talph_bw\\n rast = (\\n eta_mb[None]\\n * C_m\\n * np.exp(-dalpha_r * (-x[:, None] + cable_len))\\n * np.exp(-dalpha_m * (-x[:, None] + cable_len))\\n / (np.exp(gamma / temp_real_kelvin) - 1)\\n )\\n\\n ds = DataStore(\\n {\\n \\\"TMPR\\\": ([\\\"x\\\", \\\"time\\\"], temp_real_celsius),\\n \\\"st\\\": ([\\\"x\\\", \\\"time\\\"], st),\\n \\\"ast\\\": ([\\\"x\\\", \\\"time\\\"], ast),\\n \\\"rst\\\": ([\\\"x\\\", \\\"time\\\"], rst),\\n \\\"rast\\\": ([\\\"x\\\", \\\"time\\\"], rast),\\n \\\"userAcquisitionTimeFW\\\": ([\\\"time\\\"], np.ones(nt)),\\n \\\"userAcquisitionTimeBW\\\": ([\\\"time\\\"], np.ones(nt)),\\n \\\"cold\\\": ([\\\"time\\\"], ts_cold),\\n \\\"warm\\\": ([\\\"time\\\"], ts_warm),\\n },\\n coords={\\\"x\\\": x, \\\"time\\\": time},\\n attrs={\\\"isDoubleEnded\\\": \\\"1\\\"},\\n )\\n\\n sections = {\\n \\\"cold\\\": [slice(0.0, x[nx_per_sec - 1])],\\n \\\"warm\\\": [slice(x[nx_per_sec], x[2 * nx_per_sec - 1])],\\n }\\n ms = [\\n (\\n slice(x[2 * nx_per_sec], x[3 * nx_per_sec - 1]),\\n slice(x[3 * nx_per_sec], x[4 * nx_per_sec - 1]),\\n True,\\n ),\\n (\\n slice(x[5 * nx_per_sec], x[6 * nx_per_sec - 1]),\\n slice(x[6 * nx_per_sec], x[7 * nx_per_sec - 1]),\\n False,\\n ),\\n ]\\n\\n ds.calibration_double_ended(\\n sections=sections,\\n st_var=0.5,\\n ast_var=0.5,\\n rst_var=0.1,\\n rast_var=0.1,\\n method=\\\"wls\\\",\\n solver=\\\"sparse\\\",\\n trans_att=[x[3 * nx_per_sec], x[6 * nx_per_sec]],\\n matching_sections=ms,\\n )\\n\\n assert_almost_equal_verbose(temp_real_celsius, ds.tmpf.values, decimal=7)\\n assert_almost_equal_verbose(temp_real_celsius, ds.tmpb.values, decimal=7)\\n assert_almost_equal_verbose(temp_real_celsius, ds.tmpw.values, decimal=7)\\n pass\",\n \"def sinh(ang):\\r\\n if not isinstance(ang, dec.Decimal):\\r\\n ang = dec.Decimal(ang)\\r\\n context = getcontext()\\r\\n context.prec += 2\\r\\n num = ang * ang\\r\\n den = 5\\r\\n term = ang * num / 6\\r\\n total = ang + term\\r\\n while True:\\r\\n prev = dec.Decimal(term)\\r\\n term *= num / den / (den - 1)\\r\\n if term == 0 or term.logb() < total.logb() - context.prec:\\r\\n context.prec -= 2\\r\\n return +total\\r\\n total += term\\r\\n den += 2\",\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 aeroFus(F,alpha,beta,rp,V0=50.):\\r\\n a = alpha * m.pi/180;\\r\\n S_Cyl = 0.25 * m.pi * F.cD ** 2;\\r\\n f_F = (F.cL + F.bL + F.nL) / F.cD;\\r\\n FF = 1. + 2.2/(f_F ** (1.5)) - 0.9/(f_F ** (3.));\\r\\n gen = F.getGen();\\r\\n x = np.concatenate([np.linspace(0,gen[17,0],50), np.linspace(gen[17,0],gen[18,0],100),np.linspace(gen[18,0],gen[19,0],100)]);\\r\\n ReX = V0*x/(1.57e-5);\\r\\n delta = np.concatenate([[0.],4.92*x[1:50]/(ReX[1:50]**(0.5)),4.92*x[50]/(ReX[50]**(0.5))+0.35*(x[50:]-x[50])/(ReX[50:]**(0.2))]);\\r\\n rayon = np.interp(x,gen[:,0],gen[:,1])+delta;\\r\\n S = m.pi * rayon ** 2;\\r\\n cp_X = (x[1:]+x[:-1])*0.5;\\r\\n dS = S[1:]-S[:-1];\\r\\n \\r\\n CN_lin = np.sin(2.*a) * S[-1];\\r\\n CX_lin = np.sin(a)**2 * S[-1];\\r\\n L_lin = CN_lin * np.cos(a) - CX_lin * np.sin(a);\\r\\n D_lin = CN_lin * np.sin(a) + CX_lin * np.cos(a);\\r\\n M_lin = -np.sin(2.*a) * np.sum(dS*cp_X);\\r\\n ReF = V0 * cp_X /(1.57e-5);\\r\\n CF = np.concatenate([1.328/(ReF[:49]**0.5), 0.0442/(ReF[49:]**(1./6.))]);\\r\\n dX = x[1:]-x[:-1];\\r\\n r2 = np.interp(x,gen[:,0],gen[:,1]);\\r\\n ds = ((r2[1:]-r2[:-1])**2 + dX ** 2) ** (0.5);\\r\\n rMoy = (r2[1:]+r2[:-1])*0.5;\\r\\n dSW = 2*m.pi*ds*rMoy;\\r\\n Frot = np.sum(CF*dSW)*FF;\\r\\n D_Culot = 0.14*0.25 * m.pi * F.bD**2; # Lecture Aerodynamics 2A : slender body\\r\\n if F.bL/F.cD < 0.8:\\r\\n D_con = 1.4*S_Cyl;\\r\\n else:\\r\\n D_con = 1.4 * m.exp(-((F.bL/F.cD)-0.8)*3./0.8) * S_Cyl;\\r\\n D_windscreen = S_Cyl * 2.e-3;\\r\\n D_par = (Frot+D_Culot + D_con + D_windscreen);\\r\\n# D_par = (Frot + D_con + D_windscreen);\\r\\n Cx = 1.2; # Allen ensures that for transversal flow ok if no compressible effect\\r\\n L_visc = np.sin(a) * np.abs(np.sin(a)) * np.cos(a) * Cx * np.sum(2.*dX*rMoy);\\r\\n D_visc = np.abs(np.sin(a) ** 3) * Cx * np.sum(2.*dX*rMoy);\\r\\n M_visc = - Cx * np.abs(np.sin(a)) * np.sin(a) * np.sum(2.*dX*rMoy*cp_X);\\r\\n \\r\\n L = L_lin + L_visc - D_par * np.sin(a);\\r\\n D = D_lin + D_visc + D_par * np.cos(a);\\r\\n Moment = M_lin + M_visc;\\r\\n d = ((rp[0] + F.hDist) ** 2 + (rp[2]+F.vDist)**2)**(0.5);\\r\\n TP = np.arctan2(-(rp[2]+F.vDist),(rp[0]+F.hDist));\\r\\n M = Moment + d * L * np.cos(TP+a) + d * D * np.sin(TP + a);\\r\\n \\r\\n beta *= m.pi/180.;\\r\\n CN_lin = np.sin(2.*beta) * S[-1];\\r\\n CX_lin = np.sin(beta)**2 * S[-1];\\r\\n Y_lin = - CN_lin * np.cos(beta) + CX_lin * np.sin(beta);\\r\\n D_lin = CN_lin * np.sin(beta) + CX_lin * np.cos(beta);\\r\\n N_lin = np.sin(2.*beta) * np.sum(dS*cp_X);\\r\\n Y_visc = - np.sin(beta) * np.abs(np.sin(beta)) * np.cos(beta) * Cx * np.sum(2.*dX*rMoy);\\r\\n D_visc = np.abs(np.sin(beta) ** 3) * Cx * np.sum(2.*dX*rMoy);\\r\\n N_visc = Cx * np.abs(np.sin(beta)) * np.sin(beta) * np.sum(2.*dX*rMoy*cp_X);\\r\\n N = N_lin + N_visc;\\r\\n Y = Y_lin + Y_visc + D_par * np.sin(beta);\\r\\n Dt = D_lin + D_visc;\\r\\n D += Dt;\\r\\n dv = rp[0] + F.hDist;\\r\\n dvt = F.bL+F.cL+F.nL - dv;\\r\\n TPv = np.arctan2(-rp[1],(rp[0]+F.hDist));\\r\\n N += dv * (Y_lin + Y_visc) * m.cos(TPv - beta) + dv * Dt * m.sin(TPv-beta) + D_par * np.sin(beta) * dvt ;\\r\\n Y = 0.; \\r\\n return L,D,M,Y,N\",\n \"def gen_OSA(self, time_window_ps, center_wavelength_nm, power, \\n power_is_epp = False,\\n fileloc = 'O:\\\\\\\\OFM\\\\\\\\Maser\\\\\\\\Dual-Comb 100 MHz System\\\\\\\\Pump spectrum-Yb-101614.csv',\\n log = True, rows = 30): # Yb spectrum\\n \\n try:\\n self.fileloc = fileloc\\n \\n self.set_time_window_ps(time_window_ps)\\n \\n self.center_wl = center_wavelength_nm # reference wavelength (nm) \\n \\n self.w0 = (2. * np.pi * self.c) / self.center_wl # reference angular frequency \\n \\n self.setup_grids()\\n \\n if not power_is_epp: \\n power = power / self.frep\\n \\n # Read in OSA data\\n osa_data = np.genfromtxt(self.fileloc, delimiter = ',', skiprows = rows) \\n \\n wavelengths = osa_data[:,0]# (nm)\\n wavelengths = self.internal_wl_from_nm(wavelengths)\\n \\n intensity = osa_data[:,1]# (arb. units)\\n\\n if log:\\n intensity = 10.**(intensity / 10.)\\n \\n freq_abs = self.c/wavelengths\\n freq_abs = np.sort(freq_abs)\\n \\n self.freq_rel = freq_abs - self.c / self.center_wl\\n \\n pulse_envelope = interp1d(self.freq_rel, intensity, kind='linear',\\n bounds_error = False, fill_value=0)\\n \\n self.gridded_intensity = pulse_envelope(self.V / (2*np.pi))\\n \\n # Calculate time domain complex electric field A\\n self.A = IFFT_t(self.gridded_intensity)\\n # Calculate normalization factor to achieve requested \\n # pulse energy\\n e_scale = np.sqrt(power / self.calc_epp() )\\n self.A = self.A * e_scale\\n \\n except IOError:\\n print ('File not found.')\",\n \"def twostr_func(wavelength, F_s, solarzenithangle,albedo_dif, \\n\\t\\t\\talbedo_dir, temp_ground, w_0, g, tau_n, temp_c):\\n\\t\\n\\t########################\\n\\t###Import useful libraries\\n\\t########################\\n\\timport numpy as np\\n\\timport pdb\\n\\timport scipy.linalg\\n\\n\\n\\n\\n\\t########################\\n\\t###Define model parameters\\n\\t########################\\n\\t#Properties of the ground\\n\\temissivity_ground=1.-albedo_dif #emissivity of ground. 1=perfect BB emitter.\\n\\n\\t#Optical depth structure\\n\\tNlayer=len(tau_n) #number of layers in the atmospheric model.\\n\\t\\n\\ttau_c=np.zeros(Nlayer+1)# tau_c[n] is the cumulative optical depth at the upper edge of layer n. So tau_c[0]=0, and tau_c[N] is the maximum possible.\\n\\tfor n in range(0, Nlayer):\\n\\t\\ttau_c[n+1]=tau_c[n]+tau_n[n] \\n\\n\\t#In the Toon formalism, j=0 corresponds to space, and j=N+1 corresponds to the planet surface.\\n\\t#These points in wavelength space define the edges of the bins in tau space. \\n\\t#Other terminology:\\n\\t#\\ttau_c=cumulative optical depth of layers *above* layer n. \\n\\t#\\ttau_n=total optical depth of the layer n\\n\\t#\\ttau=total optical depth at any point within a layer n, hence satisfying 0<tau<tau_n\\n\\n\\tmu_0=np.cos(solarzenithangle) #\\\"incident direction of solar beam\\\"\\n\\n\\n\\t########################\\n\\t###Determine the two-stream approximation coefficients.\\n\\t########################\\n\\t#Eddington and quadrature are good at solar wavelengths (i.e., not thermal blackbody dominated). delta scalings of Joseph et al (1976) recommended to replace w_0, g, tau in this case. However, when dominated by internal isotropic sources like the Planck function, hemispheric mean approximation is preferable. When w_0=0, quadrature case has problems. This happens esp at thermal wavelengths. Again this favors using hemispheric mean at these wavelengths\\n\\t\\n\\t#We use quadrature because 1) we are at solar wavelengths for this UV work and 2) that's what twostr.f does (which is our comparison case)\\n\\tgamma_1= np.sqrt(3.)*(2.-w_0*(1.+g))/2. #consistent with Toon et al; consistent with Pierrehumbert gamma_1\\n\\tgamma_2=np.sqrt(3.)*w_0*(1.-g)/2. #consistent with Toon et al; consistent with Pierrehumbert gamma_2\\n\\tgamma_3=(1.-np.sqrt(3.)*g*mu_0)/2. #consistent with Toon et al; equal to the Pierrehumbert gamma_plus/w_0\\n\\tgamma_4=1.-gamma_3 #consistent with Toon et al; equal to the Pierrehumbert gamma_minus/w_0\\n\\tmu_1=1./np.sqrt(3.)+np.zeros(np.shape(gamma_1))#In Toon paper (eqn 18), this is given by: (1.-w_0)/(gamma_1-gamma_2). For the quadrature approximation, it is 1./np.sqrt(3.). Given its use, it seems to relate most closely to gamma_B from Pierrehumbert (see eqs 5.27, 5.30)\\n\\n\\t##Eddington\\n\\t#gamma_1= (7.-w_0*(4.+3.*g))/4.\\n\\t#gamma_2=-1.*(1.-w_0*(4.-3.*g))/4.\\n\\t#gamma_3=(2.-3.*g*mu_0)/4.\\n\\t#gamma_4=1.-gamma_3 #consistent with Toon et al; equal to the Pierrehumbert gamma_minus/w_0\\n\\t#mu_1=1./2.+np.zeros(np.shape(gamma_1))#In Toon paper (eqn 18), this is given by: (1.-w_0)/(gamma_1-gamma_2). For the quadrature approximation, it is 1./np.sqrt(3.). Given its use, it seems to relate most closely to gamma_B from Pierrehumbert (see eqs 5.27, 5.30)\\n\\n\\talambda=np.sqrt(np.abs(gamma_1*gamma_1-gamma_2*gamma_2)) #this is the lower-case lambda, from eqn 21 of Toon et al\\n\\t\\t\\t\\t\\t\\t\\t\\t #The absolute value was added based on the code Toon just sent us. This corresponds to his AK(L,J) parameter. But it should not matter since gamma_1>gamma_2 for w_0<1.\\n\\tclambda=(gamma_1-alambda)/(gamma_2) #this is the upper-case lambda, from eqn 22 of Toon et al\\n\\n\\tEMLT=np.exp(-alambda*tau_n) #this appears to be a prefactor used to facilitate computation of eqn 44 of Toon et al\\n\\te1=1.+clambda*EMLT\\n\\te2=1.-clambda*EMLT\\n\\te3=clambda+EMLT\\n\\te4=clambda-EMLT\\n\\n\\t########################\\n\\t###Set up calculation\\n\\t########################\\n\\t\\\"\\\"\\\"\\n\\tThe fundamental equation we are solving is of form:\\n\\tA_{l}*Y_{l-1}+B_{l}*Y_{l}+D{l+1}=E_{l} (equation 39 of Toon et al)\\n\\tHere, A_l, B_l, D_l, E_l are quantities we determine, and the Y_l is what we solve for.\\n\\tHence, we can summarize that we are solving a matrix equation that takes form:\\n\\tPY=E\\n\\twhere Y[l]=Y_l\\n\\t E[l]=E_l\\n\\t P[l, l-1]=A_l [row, column]\\n\\t P[l, l]=B_l\\n\\t P[l, l+1]=D_l\\n\\t P[i,j]=0 else\\n\\tToon et al use 1-indexing. Hence n runs from 1 to N, l runs from 1 to 2N, where N is the number of layers, and they have:\\n\\tY_l=Y_{1n} for l=1,3,5,...2n-1...2N-1\\n\\tY_l=Y_{2n} for l=2,4,6,...2n...2N\\n\\n\\tHowever, we use Python, which has 0-indexing. Hence *we* choose that n runs from 0 to N-1, l runs from 0 to 2N-1, and:\\n\\tY_l=Y_{1n} for l=0,2,4...2n...2N-2\\n\\tY_l=Y_{2n} for l=1,3,5...2n+1...2N-1\\n\\n\\tThe Y_{1n} and Y_{2n} are related to F^+_n and F^-_n via equations 31 and 32 of Toon et al.\\n\\tThis parametrization has been done to remove exponentials with positive operands (ie ones that could grow large and lead to numerical instabilities) from the matrix.\\n\\n\\tNote: The mapping of this PQ=R to the F+ and F- is unclear because of 1) this parametrization in terms of Y_l (done to eliminate numerical instabilities) and 2)further linear combinations done to convert a pentagiagonal matrix to an even simpler tridiagonal matrix. Hence intuitive checks are hard.\\n\\t\\\"\\\"\\\"\\n\\n\\t########################\\n\\t###Set up surface flux\\n\\t########################\\n\\tS_sfc=albedo_dir*mu_0*np.exp(-tau_c[-1]/mu_0)*np.pi*F_s+emissivity_ground*np.pi*Planck(temp_ground, wavelength)\\n\\t#Surface emission. Formed by adding blackbody emission from the ground to the reflected energy from the direct beam. The direct beam's reflected energy is assumed to be purely diffuse. This corresponds to equations 37 and 38 of Toon et al. Note that this does NOT match equation 5.31 of Pierrehumbert because it does not include the reflected diffuse radiation. So, this implicitly assumes the diffuse albedo to be 0. \\n\\n\\t########################\\n\\t###Set up C-values\\n\\t########################\\n\\t#In the reshuffled set of parameters used in this formalism, these seem analagous to the forcing term in Pierrehumbert. All the added radiation is contained in here.\\n\\n\\tdef C_plus(n, tau): #implementation of superposition of eqns 23 and 27 from Toon et al\\n\\t\\tsolarrad_denominator=alambda[n]**2.-1./mu_0**2.\\n\\t\\tsolarrad_prefactor=w_0[n]*F_s*np.pi\\n\\t\\tsolarrad_exponential=np.exp(-1.*(tau_c[n]+tau)/mu_0)\\n\\t\\tsolarrad_factor=((gamma_1[n]-1./mu_0)*gamma_3[n]+gamma_4[n]*gamma_2[n])\\n\\t\\tsolarrad=solarrad_prefactor*solarrad_factor*solarrad_exponential/solarrad_denominator #units of flux: erg/s/cm2/nm\\n\\t\\t\\n\\t\\tblackbody_prefactor=2*np.pi*mu_1[n]\\n\\t\\tB0n=Planck(temp_c[n], wavelength)\\n\\t\\tB1n=(Planck(temp_c[n+1], wavelength)-B0n)/tau_n[n] #this is effectively a slope\\n\\t\\tblackbody_factor=B0n+B1n*(tau+1./(gamma_1[n]+gamma_2[n]))\\n\\t\\tblackbody=blackbody_prefactor*blackbody_factor #start with units of the Planck function, which are: erg/s/cm2/nm/sr. But multiplying by 2pi sr restores the units of flux. So can safely add them. \\n\\t\\t\\n\\t\\tresult=solarrad+blackbody\\n\\t\\treturn result\\n\\n\\tdef C_minus(n, tau): #implementation of superposition of eqns 24 and 27 from Toon et al\\n\\t\\tsolarrad_denominator=alambda[n]**2.-1./mu_0**2.\\n\\t\\tsolarrad_prefactor=w_0[n]*F_s*np.pi\\n\\t\\tsolarrad_exponential=np.exp(-1.*(tau_c[n]+tau)/mu_0)\\n\\t\\tsolarrad_factor=((gamma_1[n]+1./mu_0)*gamma_4[n]+gamma_3[n]*gamma_2[n])\\n\\t\\tsolarrad=solarrad_prefactor*solarrad_factor*solarrad_exponential/solarrad_denominator #units of flux: erg/s/cm2/nm\\n\\t\\t\\n\\t\\tblackbody_prefactor=2*np.pi*mu_1[n]\\n\\t\\tB0n=Planck(temp_c[n], wavelength)\\n\\t\\tB1n=(Planck(temp_c[n+1], wavelength)-B0n)/tau_n[n] #this is effectively a slope\\n\\t\\tblackbody_factor=B0n+B1n*(tau-1./(gamma_1[n]+gamma_2[n]))\\n\\t\\tblackbody=blackbody_prefactor*blackbody_factor #start with units of the Planck function, which are: erg/s/cm2/nm/sr. But multiplying by 2pi sr restores the units of flux. So can safely add them. \\n\\t\\t\\n\\t\\tresult=solarrad+blackbody\\n\\t\\treturn result\\n\\n\\t########################\\n\\t###Calculate matrix coefficients\\n\\t#########################\\n\\t#initialize the A, B, D, and E.\\n\\tA=np.zeros(Nlayer*2)\\n\\tB=np.zeros(np.shape(A))\\n\\tD=np.zeros(np.shape(A))\\n\\tE=np.zeros(np.shape(A))\\n\\n\\n\\t#For l=0 (n=0) we have the boundary condition that the downward diffuse flux at the top of the first layer is equal to any incident diffuse downward flux. We set this to be zero.\\n\\tA[0]=0.\\n\\tB[0]=e1[0]\\n\\tD[0]=-1.*e2[0]\\n\\tE[0]=0.-1*C_minus(0,0) #This is really F_minus[0,0], i.e. we are assuming there is no downward diffuse flux from the top of the atmosphere.\\n\\n\\t#for l=2N-1 (n=N-1), we have the boundary condition that the upward flux at the surface is the sume of the reflected downward diffuse flux and energy from any other sources (e.g. reflected direct beam, BB emission of the ground)/np.sqrt(3.)\\n\\tA[2*Nlayer-1]=e1[Nlayer-1]-albedo_dif*e3[Nlayer-1]\\n\\tB[2*Nlayer-1]=e2[Nlayer-1]-albedo_dif*e4[Nlayer-1]\\n\\tD[2*Nlayer-1]=0.\\n\\tE[2*Nlayer-1]=S_sfc-C_plus(Nlayer-1, tau_n[Nlayer-1])+albedo_dif*C_minus(Nlayer-1, tau_n[Nlayer-1])\\n\\n\\t#There is a problem in the Toon paper. As written, the l=2n depends on e_n+1, running over the array edge. twostr.f resolves this by adopting a different mapping: their definition reduces to defining l=2(n+1) and running n from 0 to N-1. In this case, l=2 (The third value in the list of ls) depends on n=0 and n=1. This eliminates the overflow problem. We have implemented this below.\\n\\t\\n\\t##For n=1,2,3...N-1, l=2,4,6,...2N-2:\\n\\tfor n in range(0, Nlayer-1):\\n\\t\\tl=2*(n+1)\\n\\t\\tA[l]=e2[n]*e3[n]-e4[n]*e1[n]\\n\\t\\tB[l]=e1[n]*e1[n+1]-e3[n]*e3[n+1]\\n\\t\\tD[l]=e3[n]*e4[n+1]-e1[n]*e2[n+1]\\n\\t\\t\\n\\t\\tE[l]=e3[n]*(C_plus(n+1, 0.)-C_plus(n, tau_n[n]))+e1[n]*(C_minus(n,tau_n[n])-C_minus(n+1,0.))\\n\\n\\n\\t#For n=0...N-2, l=1,3...2N-3:\\n\\tfor n in range(0, Nlayer-1):\\n\\t\\tl=2*n+1\\n\\t\\tA[l]=e2[n+1]*e1[n]-e3[n]*e4[n+1]\\n\\t\\tB[l]=e2[n]*e2[n+1]-e4[n]*e4[n+1]\\n\\t\\tD[l]=e1[n+1]*e4[n+1]-e2[n+1]*e3[n+1]\\n\\t\\t\\n\\t\\tE[l]=e2[n+1]*(C_plus(n+1, 0.)-C_plus(n, tau_n[n]))-e4[n+1]*(C_minus(n+1, 0)-C_minus(n, tau_n[n])) #twostr.f has a -1*e_{4,n+1}. We have applied the same even though this is NOT what is written in the Toon et al paper. We have done this because Toon told us (6/26/2015) that there are some sign errors in the coefficients, and we currently trust the validated CLIMA code over the paper we know has errors in it. EDIT: Looking at the code Toon shared with us, he does the same. \\n\\n\\n\\t########################\\n\\t###Assemble matrix equation components\\n\\t#########################\\n\\tP=np.zeros([Nlayer*2,Nlayer*2])\\n\\n\\t#l=0: no \\\"A\\\" coefficient b/c l-1 has no meaning\\n\\tP[0,0]=B[0]\\n\\tP[0,1]=D[0]\\n\\n\\t#l=2N-1: no \\\"D\\\" coefficient b/c l+1 has no meaning\\n\\tP[2*Nlayer-1,2*Nlayer-1-1]=A[2*Nlayer-1]\\n\\tP[2*Nlayer-1,2*Nlayer-1]=B[2*Nlayer-1]\\n\\n\\tfor l in range(1, Nlayer*2-1): #This populates the matrix P in PY=E. \\n\\t\\tP[l, l-1]=A[l]\\n\\t\\tP[l,l]=B[l]\\n\\t\\tP[l,l+1]=D[l]\\n\\n\\t########################\\n\\t###Invert matrix\\n\\t#########################\\n\\t#Y=np.linalg.solve(P, E) #this is the Y_l\\n\\t\\n\\t#try using a specialized solver\\n\\tab=np.zeros([3,2*Nlayer])\\n\\tab[0,:]=np.append(0.0, np.diag(P, k=1))\\n\\tab[1,:]=np.diag(P, k=0)\\n\\tab[2,:]=np.append(np.diag(P, k=-1),0.0)\\n\\t#pdb.set_trace()\\n\\tY=scipy.linalg.solve_banded((1,1), ab, E) #this is the Y_l\\n\\n\\n\\t########################\\n\\t###Convert from Y_l to Y_1n, Y_2n\\n\\t#########################\\n\\t#The Y_1n as defined in Toon et al correspond to l=1,3, 5...2N-1. Adjusting for the zero-indexing of Python as we have done, they instead correspond to l=0,2,...2N-2\\n\\t#The Y_2n as defined in Toon et al correspond to l=2,4,6...2N. Adjusting for Python zero-indexing as we have done, they instead correspond to l=1,3,5...2N-1.\\n\\t#For detail, see eq. 40.\\n\\tY_1=np.zeros(Nlayer)\\n\\tY_2=np.zeros(Nlayer)\\n\\tfor n in range(0, Nlayer):\\n\\t\\tY_1[n]=Y[2*n]\\n\\t\\tY_2[n]=Y[2*n+1] \\n\\t\\t#last number called is Nlayer-1=N-1, so is consistent.\\n\\t\\n\\t########################\\n\\t###Convert from Y_1n, Y_2n to F_plus, F_minus\\n\\t#########################\\n\\tdef F_plus(n,tau): #defined from Eqn 31 of Toon et al.\\n\\t\\tterm1=Y_1[n]*(np.exp(-alambda[n]*(tau_n[n]-tau))+clambda[n]*np.exp(-alambda[n]*tau))\\n\\t\\tterm2=Y_2[n]*(np.exp(-alambda[n]*(tau_n[n]-tau))-clambda[n]*np.exp(-alambda[n]*tau))\\n\\t\\tterm3=C_plus(n,tau)\\n\\t\\t\\n\\t\\tresult=term1+term2+term3\\n\\t\\treturn result\\n\\n\\tdef F_minus(n, tau): #defined from Eqn 32 of Toon et al.\\n\\t\\tterm1=Y_1[n]*(clambda[n]*np.exp(-alambda[n]*(tau_n[n]-tau))+np.exp(-alambda[n]*tau))\\n\\t\\tterm2=Y_2[n]*(clambda[n]*np.exp(-alambda[n]*(tau_n[n]-tau))-np.exp(-alambda[n]*tau))\\n\\t\\tterm3=C_minus(n,tau)\\n\\t\\t\\n\\t\\tresult=term1+term2+term3\\n\\t\\treturn result\\n\\t\\n\\t########################\\n\\t###Evaluate F_plus, F_minus at boundary edges\\n\\t#########################\\n\\tF_plus_tau0=np.zeros(np.shape(tau_n))\\n\\tF_plus_taumax=np.zeros(np.shape(tau_n))\\n\\tF_minus_tau0=np.zeros(np.shape(tau_n))\\n\\tF_minus_taumax=np.zeros(np.shape(tau_n))\\n\\n\\tfor n in range(0, Nlayer):\\n\\t\\tF_plus_tau0[n]=F_plus(n, 0.)\\n\\t\\tF_plus_taumax[n]=F_plus(n, tau_n[n])\\n\\t\\tF_minus_tau0[n]=F_minus(n, 0.)\\n\\t\\tF_minus_taumax[n]=F_minus(n, tau_n[n])\\n\\n\\n\\t########################\\n\\t###Convert from Y_1n, Y_2n to F_net, mean intensity.\\n\\t#########################\\n\\t#test if diffuse flux dominates over direct flux. If direct flux dominant, instead set mu_1=mu_0\\n\\t\\n\\t#if F_minus_taumax[-1]<mu_0*np.pi*F_s*np.exp(-tau_c[-1]/mu_0):\\n\\t\\t#mu_1=np.zeros(np.shape(mu_1))+mu_0\\n\\t#mu_1=np.zeros(np.shape(mu_1))+mu_0\\n\\t\\n\\tF_net=np.zeros(np.shape(tau_n)) #defined from Eqn 48 of Toon et al. This quantity is the net flux at the BASE of layer n.\\n\\tfor n in range(0, Nlayer):\\n\\t\\tdirect=mu_0*np.pi*F_s*np.exp(-(tau_c[n]+tau_n[n])/mu_0) #eqn 50 of Toon et al\\n\\n\\t\\tterm1=Y_1[n]*(e1[n]-e3[n])\\n\\t\\tterm2=Y_2[n]*(e2[n]-e4[n])\\n\\t\\tterm3=C_plus(n, tau_n[n])-C_minus(n, tau_n[n])\\n\\t\\t\\n\\t\\tF_net[n]=term1+term2+term3 -direct\\n\\n\\tAMEAN=np.zeros(np.shape(tau_n)) #defined from Eqn 49 of Toon et al. This is the equivalent of the quantity AMEAN in the twostr.f code. It is equal to 4*np.pi*J_n, where J_n is the mean intensity at the base of layer n. Hence this quantity AMEAN should be equal to the total intensity received by a point at the base of layer n. \\n\\tfor n in range(0, Nlayer):\\n\\t\\tdirect=mu_0*np.pi*F_s*np.exp(-(tau_c[n]+tau_n[n])/mu_0) #eqn 50 of Toon et al\\n\\t\\n\\t\\tterm1=Y_1[n]*(e1[n]+e3[n])\\n\\t\\tterm2=Y_2[n]*(e2[n]+e4[n])\\n\\t\\tterm3=C_plus(n, tau_n[n])+C_minus(n, tau_n[n])\\n\\t\\t\\n\\t\\t#AMEAN[n]=(1./mu_1[n])*(term1+term2+term3)+direct/mu_0\\t\\n\\t\\tAMEAN[n]=(1./mu_1[n])*(F_plus_taumax[n]+F_minus_taumax[n])+direct/mu_0\\t\\n\\t\\n\\t########################\\n\\t###Compute \\\"surface intensity\\\"\\n\\t#########################\\t\\n\\t#\\\"Surface intensity\\\" refers to the total intensity that would be intercepted by a particle at the surface of the planet. Whereas the total intensity is equal to (F_plus[-1]+F_minus[-1])/mu_1+direct[-1]/mu_0, the surface intensity is instead equal to (F_minus[-1])/mu_1+direct[-1]/mu_0, i.e. the downwelling diffuse intensity (since the bottom intensity is cut out due to there being a planet there) plus the direct intensity\\n\\t\\n\\tsurface_intensity=(F_minus_taumax[-1]/mu_1[-1])+(np.pi*F_s)*np.exp(-(tau_c[-1])/mu_0)\\n\\t\\n\\t########################\\n\\t###Return Result\\n\\t#########################\\n\\t#F_minus_tau0\\n\\t#np.max(np.abs((F_minus_taumax[:-1]-F_minus_tau0[1:]))/F_minus_tau0[1:])\\n\\t#np.max(np.abs((F_plus_taumax[:-1]-F_plus_tau0[1:]))/F_plus_tau0[1:])\\n\\t\\n\\treturn (F_plus_tau0, F_plus_taumax, F_minus_tau0, F_minus_taumax, F_net, AMEAN, surface_intensity)\",\n \"def sin(x):\\r\\n # see decorator for function body\\r\",\n \"def fnutofwave(warr, farr):\\n c= 2.99792458e18 #spped of light in Angstroms/s\\n return farr*c/warr**2\",\n \"def sine(\\n self, cycles=1, period=1.0, peak=0.5, transient=1, skew_ratio=sb.NotSpecified, **kwargs\\n ):\\n if skew_ratio is sb.NotSpecified:\\n skew_ratio = peak\\n return dict(\\n waveform=Waveform.SINE,\\n cycles=cycles,\\n skew_ratio=skew_ratio,\\n transient=transient,\\n period=period,\\n )\",\n \"def test_sinusoidal_invalid_freq_shape():\\n with pytest.raises(ValueError):\\n d = data.Sinusoidal(input_dim=3, output_dim=7, freq=np.zeros([5, 9]))\",\n \"def trig_conditions(tr):\\n \\n\\n \\n ##############\\n #TRACE RELATED\\n ##############\\n avg_tr = np.average(tr)\\n \\n shifted_tr = tr - avg_tr \\n \\n abs_tr = abs(shifted_tr)\\n \\n sort_tr = np.sort(abs_tr)\\n \\n tr_99 = sort_tr[int(0.999*len(sort_tr))]\\n\\n #95% noise to signal area ratio calculation\\n area_big = tr_99 * int(0.95*len(sort_tr))\\n \\n area_small = np.sum(sort_tr[:int(0.95*len(sort_tr))])\\n \\n \\n area_condition = area_small / area_big; print area_condition\\n \\n # if signal is quite noisy, use recursive STALTA, else use classic STALTA\\n \\n df = tr.stats.sampling_rate\\n \\n \\n if area_condition <= 0.1:\\n \\n print(\\\"CLEAN SIGNAL!\\\\n\\\")\\n\\n ctf = abs(1-carlSTATrig(tr.data, int(5 * df), int(10 * df), 0.0001, 0.0001))\\n \\n sort_ctf = np.sort(ctf)\\n \\n ctf_low = sort_ctf[int(0.80*len(sort_ctf))]\\n \\n ctf_99 = sort_ctf[int(0.999*len(sort_ctf))]\\n \\n max_trig = ctf_99\\n \\n trig_on = ctf_low + 0.4 * (max_trig - ctf_low)\\n\\n trig_off = 0.8 * trig_on\\n \\n if not max_trig > 1.25 * ctf_low:\\n trig_on = 0; trig_off = 0;\\n \\n \\n \\n elif 0.1 < area_condition < 0.16:\\n \\n print(\\\"NOISY SIGNAL!\\\\n\\\")\\n\\n ctf = abs(1-recSTALTA(tr.data, int(5 * df), int(10 * df)))\\n \\n sort_ctf = np.sort(ctf)\\n \\n ctf_low = sort_ctf[int(0.90*len(sort_ctf))]\\n \\n ctf_99 = sort_ctf[int(0.999*len(sort_ctf))]\\n \\n max_trig = ctf_99\\n \\n trig_on = ctf_low + 0.4 * (max_trig - ctf_low)\\n\\n trig_off = 0.8 * trig_on\\n \\n if not max_trig > 1.25 * ctf_low:\\n trig_on = 0; trig_off = 0;\\n \\n else:\\n print(\\\"TRACE TOO NOISY TO DETECT SIGNAL!\\\")\\n trig_on = 0; trig_off = 0;\\n ctf = abs(1-recSTALTA(tr.data, int(5 * df), int(10 * df)))\\n\\n \\n\\n\\n\\n \\n\\n \\n \\n ############\\n #ctf RELATED\\n ############\\n\\n \\n #set conditional for noise. This is MINIMUM threshold.\\n #ctf_avg = np.average(ctf)\\n #ctf_mode = scipy.stats.mode(ctf)\\n #ctf_std = np.std(ctf)\\n \\n\\n \\n \\n #plt.figure()\\n #plt.plot(sort_ctf)\\n #plt.show()\\n\\n \\n\\n \\n \\n \\n return trig_on, trig_off, ctf\",\n \"def _get_cyclical_sin(df: pd.Series, col_name: str, col_type: str, col_max: Any):\\n return np.sin(2. * np.pi * df[\\\"{}_{}\\\".format(col_name, col_type)] / col_max)\",\n \"def sine(x, period=10.0, start_phase=0.0, name=''):\\n x = x.astype(np.float)\\n variables = {\\n 'function': sine, 'period': period, 'start_phase': start_phase}\\n y = np.sin(2*np.pi*(x / period) + start_phase)\\n return packer(x, y, variables, name=name)\",\n \"def set_frequency(self):\\r\\n def move_synth(delta_f_synth):\\r\\n sign_delta_f_synth = int(delta_f_synth/abs(delta_f_synth))\\r\\n stepsize_Hz = int(10)\\r\\n num_steps = int(abs(delta_f_synth)/stepsize_Hz)\\r\\n remainder_Hz = round(abs(delta_f_synth)%stepsize_Hz,1)\\r\\n self.synth.set_incr(stepsize_Hz, 'Hz')\\r\\n for nn in range(num_steps): # slowly move the synth by delta_f_synth in stepsize steps\\r\\n self.synth.walk(sign_delta_f_synth)\\r\\n time.sleep(0.1)\\r\\n self.synth.set_incr(remainder_Hz, 'Hz')\\r\\n self.synth.walk(sign_delta_f_synth)\\r\\n time.sleep(0.1)\\r\\n \\r\\n def get_delta_f_synth():\\r\\n #get latest f_rep,f_0\\r\\n self.get_frequency() \\r\\n #calculate required f_rep to get desired PA_freq. switches n and frep in above eq.\\r\\n f_rep_goal = (self.setfrequency - self.sign_lock * self.f_lock - self.sign_0 * self.f_0) / self.n\\r\\n # print 'f_rep_goal = %.0f Hz'%f_rep_goal\\r\\n # lock uses 3rd harmonic so synth must be set to *3\\r\\n delta_f_synth = (f_rep_goal - self.f_rep)*3 \\r\\n delta_f_synth = round(delta_f_synth,1)\\r\\n # print 'delta_f_synth = %.1f Hz'%delta_f_synth\\r\\n return delta_f_synth\\r\\n \\r\\n iteration = 0\\r\\n delta_f_synth = get_delta_f_synth()\\r\\n while abs(delta_f_synth) > self.synth_tol:\\r\\n move_synth(delta_f_synth)\\r\\n delta_f_synth = get_delta_f_synth()\\r\\n iteration += 1\\r\\n if iteration > self.max_iteration:\\r\\n # print 'REACHED MAX ITERATION: delta_f_synth = %.1f'%delta_f_synth\\r\\n break\",\n \"def test_filtfilt_filter_sinusoid(self):\\n T = 1.0\\n samples = 1000\\n\\n waveform_k0 = get_sinusoid(frequency=5, sample_rate=samples // T, dtype=self.dtype, device=self.device).squeeze(\\n 0\\n )\\n waveform_k1 = get_sinusoid(\\n frequency=200,\\n sample_rate=samples // T,\\n dtype=self.dtype,\\n device=self.device,\\n ).squeeze(0)\\n waveform = waveform_k0 + waveform_k1\\n\\n # Transfer function numerator and denominator polynomial coefficients\\n # corresponding to 8th-order Butterworth filter with 100-cycle/T cutoff.\\n # Generated with\\n # >>> from scipy import signal\\n # >>> b_coeffs, a_coeffs = signal.butter(8, 0.2)\\n b_coeffs = torch.tensor(\\n [\\n 2.39596441e-05,\\n 1.91677153e-04,\\n 6.70870035e-04,\\n 1.34174007e-03,\\n 1.67717509e-03,\\n 1.34174007e-03,\\n 6.70870035e-04,\\n 1.91677153e-04,\\n 2.39596441e-05,\\n ],\\n dtype=self.dtype,\\n device=self.device,\\n )\\n a_coeffs = torch.tensor(\\n [\\n 1.0,\\n -4.78451489,\\n 10.44504107,\\n -13.45771989,\\n 11.12933104,\\n -6.0252604,\\n 2.0792738,\\n -0.41721716,\\n 0.0372001,\\n ],\\n dtype=self.dtype,\\n device=self.device,\\n )\\n\\n # Extend waveform in each direction, preserving periodicity.\\n padded_waveform = torch.cat((waveform[:-1], waveform, waveform[1:]))\\n\\n output_waveform = F.filtfilt(padded_waveform, a_coeffs, b_coeffs)\\n\\n # Remove padding from output waveform; confirm that result\\n # closely matches waveform_k0.\\n self.assertEqual(\\n output_waveform[samples - 1 : 2 * samples - 1],\\n waveform_k0,\\n atol=1e-3,\\n rtol=1e-3,\\n )\",\n \"def sin_profile(N,N_cut,rising=False):\\n if rising:\\n sin_apo = np.zeros(N)\\n for i in range(int(N)):\\n if i>=N_cut:\\n sin_apo[i] = 1-(-1.0/(2.0*np.pi)*np.sin(2.0*np.pi*(N-i)/float(N-N_cut))+(N-i)/float(N-N_cut))\\n else:\\n sin_apo = np.ones(int(N))\\n for i in range(int(N)):\\n if i>=N_cut:\\n sin_apo[i] = (-1.0/(2.0*np.pi)*np.sin(2.0*np.pi*(N-i)/float(N-N_cut))+(N-i)/float(N-N_cut))\\n return sin_apo\",\n \"def warm_region_cal(audio_samples, fs):\\n #window the audio\\n windowed_samples = timbral_util.window_audio(audio_samples)\\n\\n # need to define a function for the roughness stimuli, emphasising the 20 - 40 region (of the bark scale)\\n min_bark_band = 10\\n max_bark_band = 40\\n mean_bark_band = (min_bark_band + max_bark_band) / 2.0\\n array = np.arange(min_bark_band, max_bark_band)\\n x = timbral_util.normal_dist(array, theta=0.01, mean=mean_bark_band)\\n x -= np.min(x)\\n x /= np.max(x)\\n\\n wr_array = np.zeros(240)\\n wr_array[min_bark_band:max_bark_band] = x\\n\\n # need to define a second array emphasising the 20 - 40 region (of the bark scale)\\n min_bark_band = 80\\n max_bark_band = 240\\n mean_bark_band = (min_bark_band + max_bark_band) / 2.0\\n array = np.arange(min_bark_band, max_bark_band)\\n x = timbral_util.normal_dist(array, theta=0.01, mean=mean_bark_band)\\n x -= np.min(x)\\n x /= np.max(x)\\n\\n hf_array = np.zeros(240)\\n hf_array[min_bark_band:max_bark_band] = x\\n\\n windowed_loud_spec = []\\n windowed_rms = []\\n\\n wr_vals = []\\n hf_vals = []\\n\\n for i in range(windowed_samples.shape[0]):\\n samples = windowed_samples[i, :]\\n N_entire, N_single = timbral_util.specific_loudness(samples, Pref=100.0, fs=fs, Mod=0)\\n\\n # append the loudness spec\\n windowed_loud_spec.append(N_single)\\n windowed_rms.append(np.sqrt(np.mean(samples * samples)))\\n\\n wr_vals.append(np.sum(wr_array * N_single))\\n hf_vals.append(np.sum(hf_array * N_single))\\n\\n mean_wr = np.mean(wr_vals)\\n mean_hf = np.mean(hf_vals)\\n weighted_wr = np.average(wr_vals, weights=windowed_rms)\\n weighted_hf = np.average(hf_vals, weights=windowed_rms)\\n\\n return mean_wr, weighted_wr, mean_hf, weighted_hf\",\n \"def sin_transition2(freq1, freq2, frames, start_idx=0, samplerate=SAMPLERATE):\\n t = (start_idx + np.arange(frames)) / samplerate\\n t = t.reshape(-1, 1)\\n return np.sin(2 * np.pi * (freq1*(t[-1]-t) + freq2*(t-t[0]))/(t[-1]-t[0]) * t).reshape(-1,1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6582506","0.6425722","0.6123549","0.6094703","0.6085024","0.6063853","0.6045906","0.6019445","0.6018563","0.60164666","0.60149175","0.60096467","0.597433","0.5969006","0.59594935","0.5911588","0.58930105","0.58714265","0.58433384","0.58316123","0.5824918","0.5785726","0.5766764","0.5765663","0.5763147","0.575691","0.57556933","0.57522464","0.5751634","0.5750402","0.5745256","0.5740429","0.57322574","0.5715662","0.57143885","0.5705655","0.57000744","0.5695024","0.5692885","0.5686552","0.5684639","0.56796485","0.56793946","0.56793946","0.5674751","0.5673088","0.5670377","0.56631625","0.5660048","0.5657547","0.56495416","0.56407136","0.56334805","0.56282496","0.56214076","0.56101704","0.5608635","0.5605748","0.560202","0.56005776","0.5595617","0.5594659","0.55915874","0.5572035","0.5570742","0.5565445","0.55609024","0.5560463","0.55535823","0.55405855","0.5533702","0.5532037","0.5529437","0.5526888","0.552102","0.55206513","0.5516658","0.5515456","0.5512867","0.551097","0.5510561","0.5499575","0.5499195","0.5496428","0.5490444","0.54870695","0.54855967","0.5472682","0.54711723","0.54682094","0.5466218","0.5457522","0.5456074","0.5452915","0.54523677","0.5450982","0.5446467","0.54383296","0.5431965","0.5427438"],"string":"[\n \"0.6582506\",\n \"0.6425722\",\n \"0.6123549\",\n \"0.6094703\",\n \"0.6085024\",\n \"0.6063853\",\n \"0.6045906\",\n \"0.6019445\",\n \"0.6018563\",\n \"0.60164666\",\n \"0.60149175\",\n \"0.60096467\",\n \"0.597433\",\n \"0.5969006\",\n \"0.59594935\",\n \"0.5911588\",\n \"0.58930105\",\n \"0.58714265\",\n \"0.58433384\",\n \"0.58316123\",\n \"0.5824918\",\n \"0.5785726\",\n \"0.5766764\",\n \"0.5765663\",\n \"0.5763147\",\n \"0.575691\",\n \"0.57556933\",\n \"0.57522464\",\n \"0.5751634\",\n \"0.5750402\",\n \"0.5745256\",\n \"0.5740429\",\n \"0.57322574\",\n \"0.5715662\",\n \"0.57143885\",\n \"0.5705655\",\n \"0.57000744\",\n \"0.5695024\",\n \"0.5692885\",\n \"0.5686552\",\n \"0.5684639\",\n \"0.56796485\",\n \"0.56793946\",\n \"0.56793946\",\n \"0.5674751\",\n \"0.5673088\",\n \"0.5670377\",\n \"0.56631625\",\n \"0.5660048\",\n \"0.5657547\",\n \"0.56495416\",\n \"0.56407136\",\n \"0.56334805\",\n \"0.56282496\",\n \"0.56214076\",\n \"0.56101704\",\n \"0.5608635\",\n \"0.5605748\",\n \"0.560202\",\n \"0.56005776\",\n \"0.5595617\",\n \"0.5594659\",\n \"0.55915874\",\n \"0.5572035\",\n \"0.5570742\",\n \"0.5565445\",\n \"0.55609024\",\n \"0.5560463\",\n \"0.55535823\",\n \"0.55405855\",\n \"0.5533702\",\n \"0.5532037\",\n \"0.5529437\",\n \"0.5526888\",\n \"0.552102\",\n \"0.55206513\",\n \"0.5516658\",\n \"0.5515456\",\n \"0.5512867\",\n \"0.551097\",\n \"0.5510561\",\n \"0.5499575\",\n \"0.5499195\",\n \"0.5496428\",\n \"0.5490444\",\n \"0.54870695\",\n \"0.54855967\",\n \"0.5472682\",\n \"0.54711723\",\n \"0.54682094\",\n \"0.5466218\",\n \"0.5457522\",\n \"0.5456074\",\n \"0.5452915\",\n \"0.54523677\",\n \"0.5450982\",\n \"0.5446467\",\n \"0.54383296\",\n \"0.5431965\",\n \"0.5427438\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68870825"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":78299,"cells":{"query":{"kind":"string","value":"rescale the sin a new min b = new max xmin = min of x xmax = max of x"},"document":{"kind":"string","value":"def scale(x, a=5, b=10, xmin=-1, xmax=1):\n return (b - a)*(x - xmin)/(xmax - xmin) + a"},"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 rescale(self, xmin, xmax):\n\n # Normalise\n self.normalise()\n\n \n # Rescale\n range = xmax-xmin\n for seg in self.segments:\n seg.lower_bound = seg.lower_bound*range + xmin\n seg.upper_bound = seg.upper_bound*range + xmin","def sin_inplace(a):","def vsini(self, i, T):\n vmin = 2 * np.pi * 695700 * self.rmin * np.sin(i * np.pi / 180) / (T * 86400)\n vmax = vmin * self.rmax / self.rmin\n return vmin, vmax","def addSin(self, scale=(2.*numpy.pi), value=1.0):\n self.fimage = None\n z = numpy.sin(2.0*numpy.pi*self.xx/float(scale)) * numpy.sin(2.0*numpy.pi*self.yy/float(scale))\n self.image += z * value\n return","def scale(inp: np.ndarray, new_min: float = 0., new_max: float = 1.,\n axis: int = -1) -> np.ndarray:\n xmax = inp.max(axis=axis, keepdims=True)\n xmin = inp.min(axis=axis, keepdims=True)\n a = (inp-xmin) / (xmax - xmin)\n y = a * (new_max - new_min) + new_min\n return y","def scale(a, tmin=0.0, tmax=1.0):\n return np.interp(a, (a.min(), a.max()), (tmin, tmax))","def lin_scale( val, x1, y1, x2, y2 ):\r\n x_range = (x2 - x1)\r\n new_val = 0\r\n if x_range is 0:\r\n new_val = y1\r\n else:\r\n y_range = ( y2 - y1 )\r\n new_val = ( ( ( val - x1 ) * y_range ) / x_range ) + y1\r\n\r\n return new_val","def _rescale(x, xlim, ylim):\n m = (ylim[1] - ylim[0]) / (xlim[1] - xlim[0])\n c = ylim[1] - m * xlim[1]\n y = m * x + c\n return y","def scale(x, minimum, maximum):\n return (x - minimum) / (maximum - minimum)","def scale(self, value):\n\t\toldscale = self.oldmax - self.oldmin\n\t\tnewscale = self.newmax - self.newmin\n\t\treturn (newscale * (value - self.oldmin) / oldscale) + self.newmin","def scale(arrayin,Amin,Amax,mask=None):\r\n if (mask==None) and (arrayin.max() - arrayin.min())!=0.0 :\r\n Bmax = arrayin.max()\r\n Bmin = arrayin.min()\r\n elif (arrayin.max() - arrayin.min())!=0.0 :\r\n ny = arrayin.shape[0]\r\n nx = arrayin.shape[1]\r\n Bmax = arrayin.min()\r\n Bmin = arrayin.max()\r\n for i in range(ny):\r\n for j in range(ny):\r\n if mask[i,j] > 0.5e0 :\r\n if arrayin[i,j] < Bmin :\r\n Bmin = arrayin[i,j]\r\n if arrayin[i,j] > Bmax :\r\n Bmax = arrayin[i,j]\r\n else :\r\n print \"andrew.bagOfns.scale : warning (arrayin.max() - arrayin.min())=0.0 \"\r\n return np.copy(arrayin)\r\n\r\n arrayout = (arrayin - Bmin)*(Amax - Amin) / (Bmax - Bmin) + Amin\r\n return arrayout","def setPlotScaling(x,y):\n dislin.trfscl(x,y)","def sin_custom(f,T,a=0,b=0):\n fs=44100\n t=np.linspace(0,T,T*fs)\n A=np.floor(a*fs*T)\n D=np.floor(b*fs*T)\n S1=np.linspace(0,1,A)\n S2=np.ones(T*fs-A-D)\n S3=np.linspace(1,0,D)\n S0=np.sin(2*np.pi*f*t) \n return(np.hstack((S1,S2,S3))*S0)","def sin(x):\n raise NotImplementedError","def rescale(num, old_min, old_max, new_min, new_max):\n old_range = old_max - old_min\n new_range = new_max - new_min\n new_val = new_min + (((num - old_min) * new_range)/old_range)\n\n return new_val","def sin(self, a):\n return math.sin(a)","def sin(x):\n return 0.0","def scale(self, value):\r\n return (float(value)-float(self.minimum))/float(self.maximum-self.minimum)*2.0 - 1.0","def sigmo_transform(x, base, amplitude, xhalf, slope):\n return base + amplitude / (1. + np.exp(-slope * (x - xhalf)))","def invmelscale(b):\n return 700.0 * (np.exp(b / 1125.0) - 1)","def normalizefunction(self , values):\n maxv = np.max(values)\n minv = np.min(values)\n def f(x):\n return (x - minv)/(maxv-minv)\n return f","def scale_servos(self, value, minrange=500, maxrange=2500):\n min_servo_range = -1\n max_servo_range = 1\n return min_servo_range + (max_servo_range - min_servo_range) / (maxrange - minrange) * (value - minrange)","def scale(self, sf):\n self.scale(sf, sf)","def sinh(x):\n raise NotImplementedError","def scale(self, value):\n return (float(value) - float(self.minimum)) / \\\n float(self.maximum - self.minimum) * 2.0 - 1.0","def test_baseline_sinusoidal(self, b0, x0, a, freq):\n x = np.linspace(-1, 1, 100)\n y = a * np.cos(2 * np.pi * freq * (x - x0)) + b0\n\n b0_guess = guess.constant_sinusoidal_offset(y)\n\n self.assertAlmostEqual(b0, b0_guess, delta=0.1)","def fakeSin(self, x, y):\n a,b = self.exp(x,y)\n c,d = self.exp(-x,-y)\n a = a-c\n b = b-d\n a, b = self.fakeDiv(a, b, 2)\n return a, b","def rescaled(M,newmin,newmax):\n mmin,mmax = M.min(),M.max()\n M2 = M.copy()\n M2 -= mmin\n M2 *= (newmax-newmin) / (mmax-mmin)\n M2 += newmin\n return M2","def transsinh_(b=None):\n rlim=1.e-6\n nmax=300\n delta=1.0\n delta_old=delta\n for n in range(nmax):\n f=delta / (np.sinh(delta) + 1.0 * 10 ** (- 60)) - 1.0 / b\n df=(np.sinh(delta) - delta * np.cosh(delta)) / np.sinh(delta) ** 2\n delta=delta - 0.5 * f / df\n if ((n == nmax) and (np.abs((delta - delta_old) / delta_old) > rlim)):\n disp_([char(' Convergence problem in transsinh dist. function !!! ')])\n disp_([char(' residual '),num2str_((delta - delta_old) / delta_old)])\n delta_old=delta\n return delta","def scale_it(val):\n return scale(val, 0, 1, bpm_range[0], bpm_range[1])","def sinh(x):\n return 0.0","def normalize(self,x,xmin,xmax):\n return (x-xmin)/(xmax-xmin)","def normalize_data(data, min=0, max=1):\r\n import numpy as np\r\n assert isinstance(data, np.ndarray)\r\n\r\n max_value = np.max(data)\r\n min_value = np.min(data)\r\n\r\n scaled = np.interp(data, [min_value, max_value], [min, max])\r\n # convert to float64\r\n scaled = scaled.astype(np.float64)\r\n\r\n return scaled","def sin(data):\n return _make.sin(data)","def scale(curve):\n return curve/rmsd(curve)","def xsin(x):\n return x + tf.sin(x)","def scale01(arr):\r\n walk_arr_01 = numpy.interp(arr, (numpy.amin(arr), numpy.amax(arr)), (-1, +1)) # linear scaling\r\n return walk_arr_01 #return the scaled array\r","def sinegauss_a(t, t0, f0, a):\n return (np.exp(-a * (t - t0) ** 2)\n * np.exp(2j * np.pi * f0 * (t - t0)))","def sin(x):\n\tgetcontext().prec += 2\n\t#if abs(x) > 2 * pi:\n\t\t#x = x % (2 * pi)\n\ti, lasts, s, fact, num, sign = 1, 0, x, 1, x, 1\n\twhile s != lasts:\n\t\tlasts = s\n\t\ti += 2\n\t\tfact *= i * (i-1)\n\t\tnum *= x * x\n\t\tsign *= -1\n\t\ts += num / fact * sign\n\tgetcontext().prec -= 2\n\treturn +s","def linearscale(input, boundfrom, boundto, extrema=None):\n\n\tminfrom,maxfrom = boundfrom\n\tminto,maxto = boundto\n\n\t### default from bounds are min,max of the input\n\tif minfrom is None:\n\t\tif extrema:\n\t\t\tminfrom = extrema[0]\n\t\telse:\n\t\t\tminfrom = arraystats.min(input)\n\tif maxfrom is None:\n\t\tif extrema:\n\t\t\tmaxfrom = extrema[1]\n\t\telse:\n\t\t\tmaxfrom = arraystats.max(input)\n\n\trangefrom = maxfrom - minfrom\n\tif rangefrom == 0:\n\t\t# if min==max, do simple thresholding\n\t\toutput = numpy.where(input>maxfrom, maxto, minto)\n\telse:\n\t\trangeto = maxto - minto\n\t\tscale = float(rangeto) / rangefrom\n\t\toffset = minfrom * scale\n\t\toutput = input * scale - offset\n\n\treturn output","def scale(self, x: float, y: float):\n # Scaling is done from (0, 0), so that figure won't move after scaling\n dx = np.min(self.points[:, 0])\n dy = np.min(self.points[:, 1])\n self.points[:, 0] -= dx\n self.points[:, 1] -= dy\n\n matrix = np.array([\n [x, 0, 0],\n [0, y, 0],\n [0, 0, 1]\n ])\n\n self.points = self.points @ matrix\n self.points[:, 0] += dx\n self.points[:, 1] += dy\n\n self.points = self.points.astype(int)\n self.start_points = self.points\n self.center_point = self.midpoint()\n self.recalculate_pivots()","def sine(B):\n sin = math.sin\n pi = math.pi\n \n def f(x):\n return B*sin(pi*x)\n return f","def normalize(a, new_max=1.0):\n a = (a - a.min())\n a = a/a.max()\n a *= new_max\n return a","def rescale(tx):\n mins = np.amin(tx, axis=0)\n maxs = np.amax(tx, axis=0)\n txscale = (tx - mins) / (maxs - mins)\n return txscale","def _force_rescale(self, setpoint_x, setpoint_y):","def linear(minVal, maxVal, newMin, newMax, value):\n coef = ((float(value) - float(minVal)) * 100) / (float(maxVal) - float(minVal))\n newVal = float(newMin) + ((coef * (float(newMax) - float(newMin))) / 100)\n return newVal","def rescale_arr(arr, amin, amax):\r\n\r\n # old bounds\r\n m = arr.min()\r\n M = arr.max()\r\n # scale/offset\r\n s = float(amax - amin) / (M - m)\r\n d = amin - s * m\r\n\r\n # Apply clip before returning to cut off possible overflows outside the\r\n # intended range due to roundoff error, so that we can absolutely guarantee\r\n # that on output, there are no values > amax or < amin.\r\n return np.clip(s * arr + d, amin, amax)","def scale(val, src, dst):\r\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]","def autoscale(self, A):\n self.vmin = ma.min(A)\n self.vmax = ma.max(A)","def sinh(a):","def scale(self, sx, sy):\n self._impl.scale(sx, sy)","def beta_range_s_circular(s,sma):\n #sma**2. = s**2. + y**2.\n if s > sma: #failure mode/nonphysical\n s = sma\n y = np.sqrt(sma**2.-s**2.)\n beta_min = np.pi/2. - np.arctan2(y,s)\n beta_max = np.pi/2. + np.arctan2(y,s)\n return beta_min, beta_max","def scale(input):\n return (input - np.min(input)) / ((np.max(input) - np.min(input)))","def saturate_scalar_minmax(value, max_value, min_value):\n mean = (max_value + min_value)/2.0\n half_range = (max_value - min_value)/2.0\n return saturate_vector_dg(value-mean, half_range) + mean","def uniformize(self):\n\n self.len = len(self.x)\n\n if self.len > 1:\n # comput length of the shape:\n shape_length, scale = self.euclidian_length()\n\n # find new points:\n new_shape = Stroke()\n new_shape.x = []\n new_shape.y = []\n step = shape_length / float(self.len)\n biggest_smoller_point = 0\n new_shape.append(self.x[0], self.y[0])\n for i in 1 + np.array(range(len(self.x) - 1)):\n try:\n while i * step > scale[biggest_smoller_point]:\n biggest_smoller_point += 1\n\n biggest_smoller_point -= 1\n x0 = self.x[biggest_smoller_point]\n y0 = self.y[biggest_smoller_point]\n x1 = self.x[biggest_smoller_point + 1]\n y1 = self.y[biggest_smoller_point + 1]\n diff = float(i * step - scale[biggest_smoller_point])\n dist = float(scale[biggest_smoller_point + 1] - scale[biggest_smoller_point])\n new_x = x0 + diff * (x1 - x0) / dist\n new_y = y0 + diff * (y1 - y0) / dist\n new_shape.append(new_x, new_y)\n\n except IndexError:\n print i * step\n print biggest_smoller_point\n print scale\n # new_shape.append(self.x[-1], self.y[-1])\n\n\n self.x = new_shape.x\n self.y = new_shape.y\n self.len = new_shape.len","def f(x):\r\n\treturn np.sin(x)","def sinh(self):\r\n getcontext().prec += 2\r\n re = sinh(self._real) * cos(self._imag)\r\n im = cosh(self._real) * sin(self._imag)\r\n ans = self.__class__(re, im)\r\n getcontext().prec -= 2\r\n return +ans","def Sin(num):\n return math.sin(float(num))","def make_sinusoid_signal(position, num_channels, min_timescale=1.0, max_timescale=1e4):\n num_timescales = num_channels // 2\n log_timescale_increment = (\n math.log(float(max_timescale) / float(min_timescale)) /\n (tf.to_float(num_timescales) - 1))\n inv_timescales = min_timescale * tf.exp(\n tf.to_float(tf.range(num_timescales)) * -log_timescale_increment)\n\n # scaled_time: tf.shape(positon) + [num_timescales]\n scaled_time = tf.expand_dims(position, -1) * tf.reshape(inv_timescales, [1] * position.shape.ndims + [-1])\n signal = tf.concat([tf.sin(scaled_time), tf.cos(scaled_time)], axis=-1)\n signal = tf.pad(signal, [[0, 0]] * position.shape.ndims + [[0, tf.mod(num_channels, 2)]])\n return signal","def convert_sin(node, **kwargs):\n return create_basic_op_node('Sin', node, kwargs)","def scale(val, src, dst):\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]","def scale(val, src, dst):\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]","def appmag(x, xlim=(8, -4), ylim=(64, 192)):\n min_x, max_x = xlim\n min_y, max_y = ylim\n return min_y + (max_y - min_y) * (x - min_x) / (max_x - min_x)","def rescale(x):\n if x.min() != 0:\n raise ValueError('input should have min zero.')\n\n x /= x.max() # max 1\n x *= 2 # max 2\n x -= 1 # range -1, 1\n\n if x.min() != -1 and x.max() != 1:\n raise Exception\n\n return x","def current_to_signal(raw_in, scaling):\n if raw_in > scaling.RAWMAX:\n return 0.0\n result = raw_in - scaling.RAWMIN\n result *= (scaling.EUMAX - scaling.EUMIN) / (scaling.RAWMAX - scaling.RAWMIN)\n result += scaling.EUMIN\n return result","def normalize(x, x_max, x_min):\n return (x - x_min) / (x_max - x_min)","def scale(val, src, dst):\n return ((val - src[0]) / (src[1] - src[0])) * (dst[1] - dst[0]) + dst[0]","def rescale(range1, range2):\n min1, max1, min2, max2 = min(range1), max(range1), min(range2), max(range2)\n def resize(value):\n return (((value - min1) * (max2 - min2)) / (max1 - min1)) + min2\n return resize","def scale(self, from_min, from_max, to_min, to_max):\n for i in range(len(self.poses)):\n self.poses[i].position.scale(from_min[:3], from_max[:3], to_min[:3], to_max[:3])\n self.wrenches[i].scale(from_min[3:], from_max[3:], to_min[3:], to_max[3:])","def setScaleY(self,starty,endy):\r\n if starty == endy:# Prevent /0 errors when scaling\r\n endy += 0.1\r\n self.scaleLock.acquire()\r\n self.scaley = [starty,endy]\r\n self.scaleLock.release()","def sinegauss_PSD(f, t0, f0, a):\n Pf = np.pi / a * np.exp(-2 * np.pi ** 2 * (f - f0) ** 2 / a)\n Pmf = np.pi / a * np.exp(-2 * np.pi ** 2 * (-f - f0) ** 2 / a)\n return Pf + Pmf","def sfunc(self,x,y):\n return np.exp(-(x-self.x_0)**2.0-(y-self.y_0)**2.0)","def interpolate_to_amplitude(a):\n a_min = a.min()\n a_max = a.max()\n return np.interp(a, (a_min, a_max), (0, 1))","def calc_scales(self, params_in):\n if self.use_scales:\n scale = params_in[0]\n B = params_in[1]\n sin_sq_theta = self.miller_array.two_theta(wavelength=self.wavelength) \\\n .sin_theta_over_lambda_sq().data()\n\n scales = scale * self.miller_array.data()\n exp_arg = flex.double(-2 * B * sin_sq_theta)\n return flex.double(flex.double(scales) * flex.exp(exp_arg))\n else:\n # Horrible way to get vector of ones...\n return flex.double(self.miller_array.data()/self.miller_array.data())","def normalize(x, min_x, max_x):\n\treturn (x - min_x) / (max_x - min_x)","def fit_to_range(val: float, a: float, b: float, a1: float, b1: float) -> float:\n new_value = ((val - a) / (b - a)) * (b1 - a1) + a1\n return new_value","def sin(self):\r\n getcontext().prec += 2\r\n re = sin(self._real) * cosh(self._imag)\r\n im = cos(self._real) * sinh(self._imag)\r\n ans = self.__class__(re, im)\r\n getcontext().prec -= 2\r\n return +ans","def f(x):\n\treturn np.sin(x / 5.0) * np.exp(x / 10.0) + 5 * np.exp(-x / 2.0)","def scale(x, feature_range=(-1,1)):\r\n x = x * 2 - 1\r\n return x","def f_sin(k):\n return k * k * k * pk(k, suppression)","def plot_sin_cos_representation(\n a_coeff: np.ndarray,\n b_coeff: np.ndarray,\n y_points: ArrayLike,\n start: float = -10,\n end: float = 10,\n) -> None:\n x_s = np.linspace(start, end, 5000)\n y_s = [eval_sin_cos_representation(t, a_coeff, b_coeff) for t in x_s]\n\n n_len = len(y_points)\n x_points = np.array([(2 * np.pi * i) / n_len for i in range(n_len)])\n\n plt.figure(figsize=(14, 7))\n plt.plot(x_s, y_s)\n plt.scatter(x_points, y_points, c=\"black\")\n plt.show()","def normalization(x, x_min=-5.12, x_max=5.12):\n for i in range(len(x.vect)):\n x.vect[i] = x_min + x.vect[i]*(x_max-x_min)\n return x","def scale(self, smin=0.6, smax=2.0, N=20):\n scaled_geoms = []\n for s in np.linspace(smin, smax, N):\n scaled_atomlist = []\n for (Zi,[xi,yi,zi]) in self.atomlist0:\n scaled_atomlist.append( (Zi, (xi*s,yi*s,zi*s)) )\n scaled_geoms.append(scaled_atomlist)\n return scaled_geoms","def remap(x: float, min_x: float, max_x: float, min_y: float, max_y: float) -> float:\n return min_y + (max_y - min_y) * ((x - min_x) / (max_x - min_x))","def schwefel(indiv):\n\ttamanho = len(indiv)\n\n\ty = 418.9829 * tamanho - sum([-x * math.sin(math.sqrt(math.fabs(x))) for x in indiv])\n\treturn y","def scale_range(x, input_range, target_range):\n\n range = [np.amin(x), np.amax(x)]\n x_std = (x - input_range[0]) / (1.0*(input_range[1] - input_range[0]))\n x_scaled = x_std * (1.0*(target_range[1] - target_range[0])) + target_range[0]\n return x_scaled, range","def normalize_wrt_max(self):\n\n x_min = min(self.x)\n x_max = max(self.x)\n y_min = min(self.y)\n y_max = max(self.y)\n\n x_range = x_max - x_min\n y_range = y_max - y_min\n max_range = max(x_range, y_range)\n\n x = np.array(self.x)\n y = np.array(self.y)\n x -= x_min\n y -= y_min\n x = x / float(max_range)\n y = y / float(max_range)\n\n self.x = x.tolist()\n self.y = y.tolist()","def _scale_setter(self, value: float) -> None:\n self.uaxis.scale = value\n self.vaxis.scale = value","def scale(self, points, inplace=True):\n points = np.array(points).astype(float)\n if inplace==False:\n points = points.copy()\n # if len(points.shape) == 1:\n # points = points[None,:]\n # if len(points.shape) != 2:\n # logger.error(\"cannot scale array of dimensions\".format(len(points.shape)))\n points -= self.origin\n points /= self.scale_factor\n return points","def f(x):\r\n return x * np.sin(x)","def _min_max_scale(arr, new_range=(0, 255)):\n # get array's current min and max\n mn = arr.min()\n mx = arr.max()\n\n # check if scaling needs to be done to be in new_range\n if mn < new_range[0] or mx > new_range[1]:\n # perform min-max scaling\n scaled = (new_range[1] - new_range[0]) * (arr - mn) / (mx - mn) + new_range[0]\n else:\n # return array if already in range\n scaled = arr\n\n return scaled","def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n inputrange = float(input_interval_end) - float(input_interval_start) #finds length or original interval\n outputrange = float(output_interval_end) - float(output_interval_start) #finds length of target interval\n scaledvalue = float(val) - input_interval_start #finds how far through the interval the value is \n value = ( scaledvalue / inputrange ) * outputrange + output_interval_start\n return value","def norm_funct(x,min_x,max_x,a=-1,b=1):\n return (b-a)*((x-min_x)/(max_x - min_x)) + a","def sin(x):\r\n # see decorator for function body\r","def sin(angle):\n return math.sin(math.radians(angle))","def normalize(image_data, a=0.1, b=0.9):\n # Implement Min-Max scaling for image data\n return a + (((image_data-np.min(image_data)) * (b - a)) / (np.max(image_data) - np.min(image_data)))","def scale_floor(value, old_max, new_max):\n\tassert value >= 0\n\tassert value <= old_max\n\treturn new_max * value / old_max","def function_to_minimize(x):\n return math.sin(x[0]) * math.cos(x[1]) + math.cos(x[0] + x[1]) + random.uniform(-0.02, 0.02)","def atmgaincal(self,flim=[10000,10500]):\n sind=self.getscanind()\n ind=self.expandcal()\n amm=np.tile(self.am,(self.nf,1)).T\n x=(self.spec-self.b[ind])/self.g[ind];x=x[sind]\n x=x/amm[sind]\n y=x[ np.where((self.za[sind]>=25) & (self.za[sind]<=35))[0] ]\n \n #for k in range(y.shape[0]):\n # y[k]=y[k]-np.nanmedian(y[k])\n\n f=self.f+9500\n find=np.where((f>=flim[0]) & (f<=flim[1]))[0]\n \n for k in range(y.shape[0]):\n x=self.f[find];\n yy=y[k,find];\n p=np.polyfit(x,yy,deg=1);\n y[k]=y[k]-np.poly1d(p)(self.f)\n\n return y","def sin(x):\n if isinstance(x, int):\n x = Expression(x)\n return _sin(x)"],"string":"[\n \"def rescale(self, xmin, xmax):\\n\\n # Normalise\\n self.normalise()\\n\\n \\n # Rescale\\n range = xmax-xmin\\n for seg in self.segments:\\n seg.lower_bound = seg.lower_bound*range + xmin\\n seg.upper_bound = seg.upper_bound*range + xmin\",\n \"def sin_inplace(a):\",\n \"def vsini(self, i, T):\\n vmin = 2 * np.pi * 695700 * self.rmin * np.sin(i * np.pi / 180) / (T * 86400)\\n vmax = vmin * self.rmax / self.rmin\\n return vmin, vmax\",\n \"def addSin(self, scale=(2.*numpy.pi), value=1.0):\\n self.fimage = None\\n z = numpy.sin(2.0*numpy.pi*self.xx/float(scale)) * numpy.sin(2.0*numpy.pi*self.yy/float(scale))\\n self.image += z * value\\n return\",\n \"def scale(inp: np.ndarray, new_min: float = 0., new_max: float = 1.,\\n axis: int = -1) -> np.ndarray:\\n xmax = inp.max(axis=axis, keepdims=True)\\n xmin = inp.min(axis=axis, keepdims=True)\\n a = (inp-xmin) / (xmax - xmin)\\n y = a * (new_max - new_min) + new_min\\n return y\",\n \"def scale(a, tmin=0.0, tmax=1.0):\\n return np.interp(a, (a.min(), a.max()), (tmin, tmax))\",\n \"def lin_scale( val, x1, y1, x2, y2 ):\\r\\n x_range = (x2 - x1)\\r\\n new_val = 0\\r\\n if x_range is 0:\\r\\n new_val = y1\\r\\n else:\\r\\n y_range = ( y2 - y1 )\\r\\n new_val = ( ( ( val - x1 ) * y_range ) / x_range ) + y1\\r\\n\\r\\n return new_val\",\n \"def _rescale(x, xlim, ylim):\\n m = (ylim[1] - ylim[0]) / (xlim[1] - xlim[0])\\n c = ylim[1] - m * xlim[1]\\n y = m * x + c\\n return y\",\n \"def scale(x, minimum, maximum):\\n return (x - minimum) / (maximum - minimum)\",\n \"def scale(self, value):\\n\\t\\toldscale = self.oldmax - self.oldmin\\n\\t\\tnewscale = self.newmax - self.newmin\\n\\t\\treturn (newscale * (value - self.oldmin) / oldscale) + self.newmin\",\n \"def scale(arrayin,Amin,Amax,mask=None):\\r\\n if (mask==None) and (arrayin.max() - arrayin.min())!=0.0 :\\r\\n Bmax = arrayin.max()\\r\\n Bmin = arrayin.min()\\r\\n elif (arrayin.max() - arrayin.min())!=0.0 :\\r\\n ny = arrayin.shape[0]\\r\\n nx = arrayin.shape[1]\\r\\n Bmax = arrayin.min()\\r\\n Bmin = arrayin.max()\\r\\n for i in range(ny):\\r\\n for j in range(ny):\\r\\n if mask[i,j] > 0.5e0 :\\r\\n if arrayin[i,j] < Bmin :\\r\\n Bmin = arrayin[i,j]\\r\\n if arrayin[i,j] > Bmax :\\r\\n Bmax = arrayin[i,j]\\r\\n else :\\r\\n print \\\"andrew.bagOfns.scale : warning (arrayin.max() - arrayin.min())=0.0 \\\"\\r\\n return np.copy(arrayin)\\r\\n\\r\\n arrayout = (arrayin - Bmin)*(Amax - Amin) / (Bmax - Bmin) + Amin\\r\\n return arrayout\",\n \"def setPlotScaling(x,y):\\n dislin.trfscl(x,y)\",\n \"def sin_custom(f,T,a=0,b=0):\\n fs=44100\\n t=np.linspace(0,T,T*fs)\\n A=np.floor(a*fs*T)\\n D=np.floor(b*fs*T)\\n S1=np.linspace(0,1,A)\\n S2=np.ones(T*fs-A-D)\\n S3=np.linspace(1,0,D)\\n S0=np.sin(2*np.pi*f*t) \\n return(np.hstack((S1,S2,S3))*S0)\",\n \"def sin(x):\\n raise NotImplementedError\",\n \"def rescale(num, old_min, old_max, new_min, new_max):\\n old_range = old_max - old_min\\n new_range = new_max - new_min\\n new_val = new_min + (((num - old_min) * new_range)/old_range)\\n\\n return new_val\",\n \"def sin(self, a):\\n return math.sin(a)\",\n \"def sin(x):\\n return 0.0\",\n \"def scale(self, value):\\r\\n return (float(value)-float(self.minimum))/float(self.maximum-self.minimum)*2.0 - 1.0\",\n \"def sigmo_transform(x, base, amplitude, xhalf, slope):\\n return base + amplitude / (1. + np.exp(-slope * (x - xhalf)))\",\n \"def invmelscale(b):\\n return 700.0 * (np.exp(b / 1125.0) - 1)\",\n \"def normalizefunction(self , values):\\n maxv = np.max(values)\\n minv = np.min(values)\\n def f(x):\\n return (x - minv)/(maxv-minv)\\n return f\",\n \"def scale_servos(self, value, minrange=500, maxrange=2500):\\n min_servo_range = -1\\n max_servo_range = 1\\n return min_servo_range + (max_servo_range - min_servo_range) / (maxrange - minrange) * (value - minrange)\",\n \"def scale(self, sf):\\n self.scale(sf, sf)\",\n \"def sinh(x):\\n raise NotImplementedError\",\n \"def scale(self, value):\\n return (float(value) - float(self.minimum)) / \\\\\\n float(self.maximum - self.minimum) * 2.0 - 1.0\",\n \"def test_baseline_sinusoidal(self, b0, x0, a, freq):\\n x = np.linspace(-1, 1, 100)\\n y = a * np.cos(2 * np.pi * freq * (x - x0)) + b0\\n\\n b0_guess = guess.constant_sinusoidal_offset(y)\\n\\n self.assertAlmostEqual(b0, b0_guess, delta=0.1)\",\n \"def fakeSin(self, x, y):\\n a,b = self.exp(x,y)\\n c,d = self.exp(-x,-y)\\n a = a-c\\n b = b-d\\n a, b = self.fakeDiv(a, b, 2)\\n return a, b\",\n \"def rescaled(M,newmin,newmax):\\n mmin,mmax = M.min(),M.max()\\n M2 = M.copy()\\n M2 -= mmin\\n M2 *= (newmax-newmin) / (mmax-mmin)\\n M2 += newmin\\n return M2\",\n \"def transsinh_(b=None):\\n rlim=1.e-6\\n nmax=300\\n delta=1.0\\n delta_old=delta\\n for n in range(nmax):\\n f=delta / (np.sinh(delta) + 1.0 * 10 ** (- 60)) - 1.0 / b\\n df=(np.sinh(delta) - delta * np.cosh(delta)) / np.sinh(delta) ** 2\\n delta=delta - 0.5 * f / df\\n if ((n == nmax) and (np.abs((delta - delta_old) / delta_old) > rlim)):\\n disp_([char(' Convergence problem in transsinh dist. function !!! ')])\\n disp_([char(' residual '),num2str_((delta - delta_old) / delta_old)])\\n delta_old=delta\\n return delta\",\n \"def scale_it(val):\\n return scale(val, 0, 1, bpm_range[0], bpm_range[1])\",\n \"def sinh(x):\\n return 0.0\",\n \"def normalize(self,x,xmin,xmax):\\n return (x-xmin)/(xmax-xmin)\",\n \"def normalize_data(data, min=0, max=1):\\r\\n import numpy as np\\r\\n assert isinstance(data, np.ndarray)\\r\\n\\r\\n max_value = np.max(data)\\r\\n min_value = np.min(data)\\r\\n\\r\\n scaled = np.interp(data, [min_value, max_value], [min, max])\\r\\n # convert to float64\\r\\n scaled = scaled.astype(np.float64)\\r\\n\\r\\n return scaled\",\n \"def sin(data):\\n return _make.sin(data)\",\n \"def scale(curve):\\n return curve/rmsd(curve)\",\n \"def xsin(x):\\n return x + tf.sin(x)\",\n \"def scale01(arr):\\r\\n walk_arr_01 = numpy.interp(arr, (numpy.amin(arr), numpy.amax(arr)), (-1, +1)) # linear scaling\\r\\n return walk_arr_01 #return the scaled array\\r\",\n \"def sinegauss_a(t, t0, f0, a):\\n return (np.exp(-a * (t - t0) ** 2)\\n * np.exp(2j * np.pi * f0 * (t - t0)))\",\n \"def sin(x):\\n\\tgetcontext().prec += 2\\n\\t#if abs(x) > 2 * pi:\\n\\t\\t#x = x % (2 * pi)\\n\\ti, lasts, s, fact, num, sign = 1, 0, x, 1, x, 1\\n\\twhile s != lasts:\\n\\t\\tlasts = s\\n\\t\\ti += 2\\n\\t\\tfact *= i * (i-1)\\n\\t\\tnum *= x * x\\n\\t\\tsign *= -1\\n\\t\\ts += num / fact * sign\\n\\tgetcontext().prec -= 2\\n\\treturn +s\",\n \"def linearscale(input, boundfrom, boundto, extrema=None):\\n\\n\\tminfrom,maxfrom = boundfrom\\n\\tminto,maxto = boundto\\n\\n\\t### default from bounds are min,max of the input\\n\\tif minfrom is None:\\n\\t\\tif extrema:\\n\\t\\t\\tminfrom = extrema[0]\\n\\t\\telse:\\n\\t\\t\\tminfrom = arraystats.min(input)\\n\\tif maxfrom is None:\\n\\t\\tif extrema:\\n\\t\\t\\tmaxfrom = extrema[1]\\n\\t\\telse:\\n\\t\\t\\tmaxfrom = arraystats.max(input)\\n\\n\\trangefrom = maxfrom - minfrom\\n\\tif rangefrom == 0:\\n\\t\\t# if min==max, do simple thresholding\\n\\t\\toutput = numpy.where(input>maxfrom, maxto, minto)\\n\\telse:\\n\\t\\trangeto = maxto - minto\\n\\t\\tscale = float(rangeto) / rangefrom\\n\\t\\toffset = minfrom * scale\\n\\t\\toutput = input * scale - offset\\n\\n\\treturn output\",\n \"def scale(self, x: float, y: float):\\n # Scaling is done from (0, 0), so that figure won't move after scaling\\n dx = np.min(self.points[:, 0])\\n dy = np.min(self.points[:, 1])\\n self.points[:, 0] -= dx\\n self.points[:, 1] -= dy\\n\\n matrix = np.array([\\n [x, 0, 0],\\n [0, y, 0],\\n [0, 0, 1]\\n ])\\n\\n self.points = self.points @ matrix\\n self.points[:, 0] += dx\\n self.points[:, 1] += dy\\n\\n self.points = self.points.astype(int)\\n self.start_points = self.points\\n self.center_point = self.midpoint()\\n self.recalculate_pivots()\",\n \"def sine(B):\\n sin = math.sin\\n pi = math.pi\\n \\n def f(x):\\n return B*sin(pi*x)\\n return f\",\n \"def normalize(a, new_max=1.0):\\n a = (a - a.min())\\n a = a/a.max()\\n a *= new_max\\n return a\",\n \"def rescale(tx):\\n mins = np.amin(tx, axis=0)\\n maxs = np.amax(tx, axis=0)\\n txscale = (tx - mins) / (maxs - mins)\\n return txscale\",\n \"def _force_rescale(self, setpoint_x, setpoint_y):\",\n \"def linear(minVal, maxVal, newMin, newMax, value):\\n coef = ((float(value) - float(minVal)) * 100) / (float(maxVal) - float(minVal))\\n newVal = float(newMin) + ((coef * (float(newMax) - float(newMin))) / 100)\\n return newVal\",\n \"def rescale_arr(arr, amin, amax):\\r\\n\\r\\n # old bounds\\r\\n m = arr.min()\\r\\n M = arr.max()\\r\\n # scale/offset\\r\\n s = float(amax - amin) / (M - m)\\r\\n d = amin - s * m\\r\\n\\r\\n # Apply clip before returning to cut off possible overflows outside the\\r\\n # intended range due to roundoff error, so that we can absolutely guarantee\\r\\n # that on output, there are no values > amax or < amin.\\r\\n return np.clip(s * arr + d, amin, amax)\",\n \"def scale(val, src, dst):\\r\\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]\",\n \"def autoscale(self, A):\\n self.vmin = ma.min(A)\\n self.vmax = ma.max(A)\",\n \"def sinh(a):\",\n \"def scale(self, sx, sy):\\n self._impl.scale(sx, sy)\",\n \"def beta_range_s_circular(s,sma):\\n #sma**2. = s**2. + y**2.\\n if s > sma: #failure mode/nonphysical\\n s = sma\\n y = np.sqrt(sma**2.-s**2.)\\n beta_min = np.pi/2. - np.arctan2(y,s)\\n beta_max = np.pi/2. + np.arctan2(y,s)\\n return beta_min, beta_max\",\n \"def scale(input):\\n return (input - np.min(input)) / ((np.max(input) - np.min(input)))\",\n \"def saturate_scalar_minmax(value, max_value, min_value):\\n mean = (max_value + min_value)/2.0\\n half_range = (max_value - min_value)/2.0\\n return saturate_vector_dg(value-mean, half_range) + mean\",\n \"def uniformize(self):\\n\\n self.len = len(self.x)\\n\\n if self.len > 1:\\n # comput length of the shape:\\n shape_length, scale = self.euclidian_length()\\n\\n # find new points:\\n new_shape = Stroke()\\n new_shape.x = []\\n new_shape.y = []\\n step = shape_length / float(self.len)\\n biggest_smoller_point = 0\\n new_shape.append(self.x[0], self.y[0])\\n for i in 1 + np.array(range(len(self.x) - 1)):\\n try:\\n while i * step > scale[biggest_smoller_point]:\\n biggest_smoller_point += 1\\n\\n biggest_smoller_point -= 1\\n x0 = self.x[biggest_smoller_point]\\n y0 = self.y[biggest_smoller_point]\\n x1 = self.x[biggest_smoller_point + 1]\\n y1 = self.y[biggest_smoller_point + 1]\\n diff = float(i * step - scale[biggest_smoller_point])\\n dist = float(scale[biggest_smoller_point + 1] - scale[biggest_smoller_point])\\n new_x = x0 + diff * (x1 - x0) / dist\\n new_y = y0 + diff * (y1 - y0) / dist\\n new_shape.append(new_x, new_y)\\n\\n except IndexError:\\n print i * step\\n print biggest_smoller_point\\n print scale\\n # new_shape.append(self.x[-1], self.y[-1])\\n\\n\\n self.x = new_shape.x\\n self.y = new_shape.y\\n self.len = new_shape.len\",\n \"def f(x):\\r\\n\\treturn np.sin(x)\",\n \"def sinh(self):\\r\\n getcontext().prec += 2\\r\\n re = sinh(self._real) * cos(self._imag)\\r\\n im = cosh(self._real) * sin(self._imag)\\r\\n ans = self.__class__(re, im)\\r\\n getcontext().prec -= 2\\r\\n return +ans\",\n \"def Sin(num):\\n return math.sin(float(num))\",\n \"def make_sinusoid_signal(position, num_channels, min_timescale=1.0, max_timescale=1e4):\\n num_timescales = num_channels // 2\\n log_timescale_increment = (\\n math.log(float(max_timescale) / float(min_timescale)) /\\n (tf.to_float(num_timescales) - 1))\\n inv_timescales = min_timescale * tf.exp(\\n tf.to_float(tf.range(num_timescales)) * -log_timescale_increment)\\n\\n # scaled_time: tf.shape(positon) + [num_timescales]\\n scaled_time = tf.expand_dims(position, -1) * tf.reshape(inv_timescales, [1] * position.shape.ndims + [-1])\\n signal = tf.concat([tf.sin(scaled_time), tf.cos(scaled_time)], axis=-1)\\n signal = tf.pad(signal, [[0, 0]] * position.shape.ndims + [[0, tf.mod(num_channels, 2)]])\\n return signal\",\n \"def convert_sin(node, **kwargs):\\n return create_basic_op_node('Sin', node, kwargs)\",\n \"def scale(val, src, dst):\\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]\",\n \"def scale(val, src, dst):\\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]\",\n \"def appmag(x, xlim=(8, -4), ylim=(64, 192)):\\n min_x, max_x = xlim\\n min_y, max_y = ylim\\n return min_y + (max_y - min_y) * (x - min_x) / (max_x - min_x)\",\n \"def rescale(x):\\n if x.min() != 0:\\n raise ValueError('input should have min zero.')\\n\\n x /= x.max() # max 1\\n x *= 2 # max 2\\n x -= 1 # range -1, 1\\n\\n if x.min() != -1 and x.max() != 1:\\n raise Exception\\n\\n return x\",\n \"def current_to_signal(raw_in, scaling):\\n if raw_in > scaling.RAWMAX:\\n return 0.0\\n result = raw_in - scaling.RAWMIN\\n result *= (scaling.EUMAX - scaling.EUMIN) / (scaling.RAWMAX - scaling.RAWMIN)\\n result += scaling.EUMIN\\n return result\",\n \"def normalize(x, x_max, x_min):\\n return (x - x_min) / (x_max - x_min)\",\n \"def scale(val, src, dst):\\n return ((val - src[0]) / (src[1] - src[0])) * (dst[1] - dst[0]) + dst[0]\",\n \"def rescale(range1, range2):\\n min1, max1, min2, max2 = min(range1), max(range1), min(range2), max(range2)\\n def resize(value):\\n return (((value - min1) * (max2 - min2)) / (max1 - min1)) + min2\\n return resize\",\n \"def scale(self, from_min, from_max, to_min, to_max):\\n for i in range(len(self.poses)):\\n self.poses[i].position.scale(from_min[:3], from_max[:3], to_min[:3], to_max[:3])\\n self.wrenches[i].scale(from_min[3:], from_max[3:], to_min[3:], to_max[3:])\",\n \"def setScaleY(self,starty,endy):\\r\\n if starty == endy:# Prevent /0 errors when scaling\\r\\n endy += 0.1\\r\\n self.scaleLock.acquire()\\r\\n self.scaley = [starty,endy]\\r\\n self.scaleLock.release()\",\n \"def sinegauss_PSD(f, t0, f0, a):\\n Pf = np.pi / a * np.exp(-2 * np.pi ** 2 * (f - f0) ** 2 / a)\\n Pmf = np.pi / a * np.exp(-2 * np.pi ** 2 * (-f - f0) ** 2 / a)\\n return Pf + Pmf\",\n \"def sfunc(self,x,y):\\n return np.exp(-(x-self.x_0)**2.0-(y-self.y_0)**2.0)\",\n \"def interpolate_to_amplitude(a):\\n a_min = a.min()\\n a_max = a.max()\\n return np.interp(a, (a_min, a_max), (0, 1))\",\n \"def calc_scales(self, params_in):\\n if self.use_scales:\\n scale = params_in[0]\\n B = params_in[1]\\n sin_sq_theta = self.miller_array.two_theta(wavelength=self.wavelength) \\\\\\n .sin_theta_over_lambda_sq().data()\\n\\n scales = scale * self.miller_array.data()\\n exp_arg = flex.double(-2 * B * sin_sq_theta)\\n return flex.double(flex.double(scales) * flex.exp(exp_arg))\\n else:\\n # Horrible way to get vector of ones...\\n return flex.double(self.miller_array.data()/self.miller_array.data())\",\n \"def normalize(x, min_x, max_x):\\n\\treturn (x - min_x) / (max_x - min_x)\",\n \"def fit_to_range(val: float, a: float, b: float, a1: float, b1: float) -> float:\\n new_value = ((val - a) / (b - a)) * (b1 - a1) + a1\\n return new_value\",\n \"def sin(self):\\r\\n getcontext().prec += 2\\r\\n re = sin(self._real) * cosh(self._imag)\\r\\n im = cos(self._real) * sinh(self._imag)\\r\\n ans = self.__class__(re, im)\\r\\n getcontext().prec -= 2\\r\\n return +ans\",\n \"def f(x):\\n\\treturn np.sin(x / 5.0) * np.exp(x / 10.0) + 5 * np.exp(-x / 2.0)\",\n \"def scale(x, feature_range=(-1,1)):\\r\\n x = x * 2 - 1\\r\\n return x\",\n \"def f_sin(k):\\n return k * k * k * pk(k, suppression)\",\n \"def plot_sin_cos_representation(\\n a_coeff: np.ndarray,\\n b_coeff: np.ndarray,\\n y_points: ArrayLike,\\n start: float = -10,\\n end: float = 10,\\n) -> None:\\n x_s = np.linspace(start, end, 5000)\\n y_s = [eval_sin_cos_representation(t, a_coeff, b_coeff) for t in x_s]\\n\\n n_len = len(y_points)\\n x_points = np.array([(2 * np.pi * i) / n_len for i in range(n_len)])\\n\\n plt.figure(figsize=(14, 7))\\n plt.plot(x_s, y_s)\\n plt.scatter(x_points, y_points, c=\\\"black\\\")\\n plt.show()\",\n \"def normalization(x, x_min=-5.12, x_max=5.12):\\n for i in range(len(x.vect)):\\n x.vect[i] = x_min + x.vect[i]*(x_max-x_min)\\n return x\",\n \"def scale(self, smin=0.6, smax=2.0, N=20):\\n scaled_geoms = []\\n for s in np.linspace(smin, smax, N):\\n scaled_atomlist = []\\n for (Zi,[xi,yi,zi]) in self.atomlist0:\\n scaled_atomlist.append( (Zi, (xi*s,yi*s,zi*s)) )\\n scaled_geoms.append(scaled_atomlist)\\n return scaled_geoms\",\n \"def remap(x: float, min_x: float, max_x: float, min_y: float, max_y: float) -> float:\\n return min_y + (max_y - min_y) * ((x - min_x) / (max_x - min_x))\",\n \"def schwefel(indiv):\\n\\ttamanho = len(indiv)\\n\\n\\ty = 418.9829 * tamanho - sum([-x * math.sin(math.sqrt(math.fabs(x))) for x in indiv])\\n\\treturn y\",\n \"def scale_range(x, input_range, target_range):\\n\\n range = [np.amin(x), np.amax(x)]\\n x_std = (x - input_range[0]) / (1.0*(input_range[1] - input_range[0]))\\n x_scaled = x_std * (1.0*(target_range[1] - target_range[0])) + target_range[0]\\n return x_scaled, range\",\n \"def normalize_wrt_max(self):\\n\\n x_min = min(self.x)\\n x_max = max(self.x)\\n y_min = min(self.y)\\n y_max = max(self.y)\\n\\n x_range = x_max - x_min\\n y_range = y_max - y_min\\n max_range = max(x_range, y_range)\\n\\n x = np.array(self.x)\\n y = np.array(self.y)\\n x -= x_min\\n y -= y_min\\n x = x / float(max_range)\\n y = y / float(max_range)\\n\\n self.x = x.tolist()\\n self.y = y.tolist()\",\n \"def _scale_setter(self, value: float) -> None:\\n self.uaxis.scale = value\\n self.vaxis.scale = value\",\n \"def scale(self, points, inplace=True):\\n points = np.array(points).astype(float)\\n if inplace==False:\\n points = points.copy()\\n # if len(points.shape) == 1:\\n # points = points[None,:]\\n # if len(points.shape) != 2:\\n # logger.error(\\\"cannot scale array of dimensions\\\".format(len(points.shape)))\\n points -= self.origin\\n points /= self.scale_factor\\n return points\",\n \"def f(x):\\r\\n return x * np.sin(x)\",\n \"def _min_max_scale(arr, new_range=(0, 255)):\\n # get array's current min and max\\n mn = arr.min()\\n mx = arr.max()\\n\\n # check if scaling needs to be done to be in new_range\\n if mn < new_range[0] or mx > new_range[1]:\\n # perform min-max scaling\\n scaled = (new_range[1] - new_range[0]) * (arr - mn) / (mx - mn) + new_range[0]\\n else:\\n # return array if already in range\\n scaled = arr\\n\\n return scaled\",\n \"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n inputrange = float(input_interval_end) - float(input_interval_start) #finds length or original interval\\n outputrange = float(output_interval_end) - float(output_interval_start) #finds length of target interval\\n scaledvalue = float(val) - input_interval_start #finds how far through the interval the value is \\n value = ( scaledvalue / inputrange ) * outputrange + output_interval_start\\n return value\",\n \"def norm_funct(x,min_x,max_x,a=-1,b=1):\\n return (b-a)*((x-min_x)/(max_x - min_x)) + a\",\n \"def sin(x):\\r\\n # see decorator for function body\\r\",\n \"def sin(angle):\\n return math.sin(math.radians(angle))\",\n \"def normalize(image_data, a=0.1, b=0.9):\\n # Implement Min-Max scaling for image data\\n return a + (((image_data-np.min(image_data)) * (b - a)) / (np.max(image_data) - np.min(image_data)))\",\n \"def scale_floor(value, old_max, new_max):\\n\\tassert value >= 0\\n\\tassert value <= old_max\\n\\treturn new_max * value / old_max\",\n \"def function_to_minimize(x):\\n return math.sin(x[0]) * math.cos(x[1]) + math.cos(x[0] + x[1]) + random.uniform(-0.02, 0.02)\",\n \"def atmgaincal(self,flim=[10000,10500]):\\n sind=self.getscanind()\\n ind=self.expandcal()\\n amm=np.tile(self.am,(self.nf,1)).T\\n x=(self.spec-self.b[ind])/self.g[ind];x=x[sind]\\n x=x/amm[sind]\\n y=x[ np.where((self.za[sind]>=25) & (self.za[sind]<=35))[0] ]\\n \\n #for k in range(y.shape[0]):\\n # y[k]=y[k]-np.nanmedian(y[k])\\n\\n f=self.f+9500\\n find=np.where((f>=flim[0]) & (f<=flim[1]))[0]\\n \\n for k in range(y.shape[0]):\\n x=self.f[find];\\n yy=y[k,find];\\n p=np.polyfit(x,yy,deg=1);\\n y[k]=y[k]-np.poly1d(p)(self.f)\\n\\n return y\",\n \"def sin(x):\\n if isinstance(x, int):\\n x = Expression(x)\\n return _sin(x)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.634048","0.6331223","0.605195","0.6003298","0.5982807","0.5972186","0.5926084","0.5825354","0.57681715","0.5748232","0.5718174","0.5701674","0.56905395","0.5674951","0.5660613","0.5647292","0.5632954","0.55880105","0.55765074","0.55494636","0.5454097","0.5436757","0.5434359","0.54295623","0.5410492","0.5404088","0.5400587","0.53935486","0.5387638","0.5385613","0.53822803","0.536076","0.5335486","0.53278685","0.5305673","0.52997035","0.52943224","0.526159","0.5247882","0.52442974","0.52436155","0.5238088","0.5227831","0.52254176","0.5223895","0.52153313","0.5214872","0.5205321","0.51851803","0.51847893","0.5184205","0.5182425","0.5182165","0.51794165","0.51791257","0.5176507","0.5170917","0.5162273","0.51610327","0.5157287","0.5153913","0.5153913","0.5149806","0.5140545","0.51341516","0.51311225","0.5130544","0.51229686","0.5122274","0.5117496","0.51168406","0.5114918","0.51133764","0.5109258","0.5109092","0.51081765","0.5107695","0.5105017","0.5104322","0.5104111","0.5092338","0.50914735","0.50914484","0.508923","0.508805","0.5083563","0.50823754","0.50807506","0.5079986","0.50755936","0.50749946","0.5074005","0.50739783","0.50668406","0.50608313","0.50603414","0.50584096","0.50547004","0.5044095","0.50361806"],"string":"[\n \"0.634048\",\n \"0.6331223\",\n \"0.605195\",\n \"0.6003298\",\n \"0.5982807\",\n \"0.5972186\",\n \"0.5926084\",\n \"0.5825354\",\n \"0.57681715\",\n \"0.5748232\",\n \"0.5718174\",\n \"0.5701674\",\n \"0.56905395\",\n \"0.5674951\",\n \"0.5660613\",\n \"0.5647292\",\n \"0.5632954\",\n \"0.55880105\",\n \"0.55765074\",\n \"0.55494636\",\n \"0.5454097\",\n \"0.5436757\",\n \"0.5434359\",\n \"0.54295623\",\n \"0.5410492\",\n \"0.5404088\",\n \"0.5400587\",\n \"0.53935486\",\n \"0.5387638\",\n \"0.5385613\",\n \"0.53822803\",\n \"0.536076\",\n \"0.5335486\",\n \"0.53278685\",\n \"0.5305673\",\n \"0.52997035\",\n \"0.52943224\",\n \"0.526159\",\n \"0.5247882\",\n \"0.52442974\",\n \"0.52436155\",\n \"0.5238088\",\n \"0.5227831\",\n \"0.52254176\",\n \"0.5223895\",\n \"0.52153313\",\n \"0.5214872\",\n \"0.5205321\",\n \"0.51851803\",\n \"0.51847893\",\n \"0.5184205\",\n \"0.5182425\",\n \"0.5182165\",\n \"0.51794165\",\n \"0.51791257\",\n \"0.5176507\",\n \"0.5170917\",\n \"0.5162273\",\n \"0.51610327\",\n \"0.5157287\",\n \"0.5153913\",\n \"0.5153913\",\n \"0.5149806\",\n \"0.5140545\",\n \"0.51341516\",\n \"0.51311225\",\n \"0.5130544\",\n \"0.51229686\",\n \"0.5122274\",\n \"0.5117496\",\n \"0.51168406\",\n \"0.5114918\",\n \"0.51133764\",\n \"0.5109258\",\n \"0.5109092\",\n \"0.51081765\",\n \"0.5107695\",\n \"0.5105017\",\n \"0.5104322\",\n \"0.5104111\",\n \"0.5092338\",\n \"0.50914735\",\n \"0.50914484\",\n \"0.508923\",\n \"0.508805\",\n \"0.5083563\",\n \"0.50823754\",\n \"0.50807506\",\n \"0.5079986\",\n \"0.50755936\",\n \"0.50749946\",\n \"0.5074005\",\n \"0.50739783\",\n \"0.50668406\",\n \"0.50608313\",\n \"0.50603414\",\n \"0.50584096\",\n \"0.50547004\",\n \"0.5044095\",\n \"0.50361806\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67776537"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":782,"numItemsPerPage":100,"numTotalItems":95772,"offset":78200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjMzMzI3MSwianRpIjoiYjlkZDhmMTEtOGI4Ni00ZjcyLWI5OWEtYjEyOTRhNGU4ZGEzIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYzMzY4NzEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.aRhBOkWDENjUaiHIIbE8QBhWbaVsG3S2YDWLgAp1g2nRT1u9WldvPu9szTTTmgX34r5WejK8PfaXq7XUNIWBCQ","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 |
|---|---|---|---|---|---|---|
Store the results of decorated function for last lookup | def memoize(func):
cache = {}
# Store results in a dict that maps arguments to results
def wrapper(*args, **kwargs):
if(args, kwargs) not in cache:
# call func() and store the result.
cache[(args,kwargs)] = func(*args,**kwargs)
return cache[(args,kwargs)]
retu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cache_result(f):\n @wraps(f)\n def wrapper(*args, **kwargs):\n assert len(args) == 0 and len(kwargs) == 0, \"Wrapped call must be empty\"\n if not hasattr(f, \"cached_result\"):\n f.cached_result = f()\n return f.cached_result\n return wrapper",
"def _memoize_return_v... | [
"0.70574814",
"0.7017321",
"0.68872094",
"0.68841857",
"0.6872656",
"0.6859558",
"0.6859039",
"0.67440945",
"0.6736466",
"0.6702753",
"0.6632642",
"0.6616202",
"0.6610168",
"0.6601362",
"0.6576083",
"0.6567744",
"0.6561982",
"0.65458673",
"0.6534694",
"0.65299016",
"0.6455248... | 0.63989127 | 24 |
Install eggs for a particular configuration | def __install_eggs(self, config):
egg_carton = (
self.directory.install_directory(self.feature_name),
"requirements.txt",
)
eggs = self.__gather_eggs(config)
self.logger.debug("Installing eggs %s..." % eggs)
self.__load_carton(egg_carton, eggs)
s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def install(self, egg, dir_path):",
"def install():\n deploy()\n configure()",
"def _install(self):\n\n pass",
"def install_egg(self, egg_name):\n if not os.path.exists(self.egg_directory):\n os.makedirs(self.egg_directory)\n self.requirement_set.add_requirement(\n ... | [
"0.6983456",
"0.66896045",
"0.6177954",
"0.60125315",
"0.6004646",
"0.59920675",
"0.5969057",
"0.590986",
"0.5858302",
"0.58255863",
"0.58191156",
"0.5809163",
"0.58055943",
"0.57812357",
"0.5772991",
"0.5771122",
"0.5763537",
"0.57495356",
"0.57216597",
"0.57147646",
"0.5714... | 0.8199708 | 0 |
add the proper resources into the environment | def __add_paths(self, config):
bin_path = os.path.join(
self.directory.install_directory(self.feature_name), "bin"
)
whitelist_executables = self._get_whitelisted_executables(config)
for f in os.listdir(bin_path):
for pattern in BLACKLISTED_EXECUTABLES:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resources(self):",
"def resources(self, resources):\n self._resources = resources",
"def add_resources(event):\n anuket_resources.need()",
"def _load_resources(self):\n puts = (getattr(self, 'project', None) or self).puts\n for resource_type, resource_cls in six.iteritems(AVAILABL... | [
"0.6918525",
"0.6601503",
"0.6575732",
"0.653603",
"0.6515601",
"0.64752585",
"0.64702904",
"0.64049286",
"0.6381827",
"0.6381827",
"0.6381827",
"0.6381827",
"0.6336196",
"0.6322255",
"0.6199193",
"0.61631304",
"0.60845155",
"0.6036984",
"0.6014663",
"0.59382975",
"0.59016645... | 0.0 | -1 |
Create a matrix of the pairwise noise correlations between cells. | def noise(date, cs, trange=(0, None), trace_type='dff',
cutoff_before_lick_ms=-1, error_trials=-1,
randomizations=500):
if isinstance(cs, list) and len(cs) == 1:
cs = cs[0]
elif isinstance(cs, list):
return _noise_multiple(date, cs, trange, trace_type,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _noise_matrix(self):\n\n return self._noise * (np.random.rand(self._rows, self._cols)\n - 0.5)",
"def _gp_cov_matrix(Nt, snr2, clen2):\n f = lambda x: np.exp(-(x**2)/clen2)\n C = snr2 * f(np.arange(Nt))\n C[0] += 1 # noise\n return scipy.linalg.toeplitz(C)",
... | [
"0.63896286",
"0.60221064",
"0.5909629",
"0.5822298",
"0.57837486",
"0.577646",
"0.5753432",
"0.567505",
"0.5652752",
"0.5638996",
"0.5632121",
"0.5631466",
"0.5631466",
"0.56234056",
"0.56053835",
"0.55994177",
"0.5569348",
"0.5540141",
"0.5540067",
"0.55052173",
"0.5498896"... | 0.5140765 | 54 |
Create a matrix of the pairwise signal correlations between cells. | def signal(date, cs, trange=(0, None), trace_type='dff',
cutoff_before_lick_ms=-1, error_trials=-1,
randomizations=500):
# ncells x frames x nstimuli/onsets
trs = stimulus.trials(date, cs, start_s=trange[0], end_s=trange[1],
trace_type=trace_type,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def correlation_matrix(data):\n\n _, num_columns = shape(data)\n\n def matrix_entry(i, j):\n return correlation(get_column(data, i), get_column(data, j))\n\n return make_matrix(num_columns, num_columns, matrix_entry)",
"def correlation_matrix(data):\n\n _, num_columns = shape(data)\n\n def ... | [
"0.6814257",
"0.6814257",
"0.6782614",
"0.67099845",
"0.65058136",
"0.6460902",
"0.61755204",
"0.6162979",
"0.61337745",
"0.6130927",
"0.61205184",
"0.6110745",
"0.61083704",
"0.609489",
"0.60805887",
"0.6067641",
"0.6061592",
"0.5999719",
"0.59809506",
"0.5967061",
"0.595325... | 0.0 | -1 |
Create a matrix of the pairwise noise correlations between cells. | def _noise_multiple(date, cs, trange=(0, None), trace_type='dff',
cutoff_before_lick_ms=-1, error_trials=-1,
randomizations=500):
# ncells x frames x nstimuli/onsets
cses, trials = cs, [0]
trs = None
for cs in cses:
cstrs = stimulus.trials(date, cs, start_s=trange[0], end_s=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _noise_matrix(self):\n\n return self._noise * (np.random.rand(self._rows, self._cols)\n - 0.5)",
"def _gp_cov_matrix(Nt, snr2, clen2):\n f = lambda x: np.exp(-(x**2)/clen2)\n C = snr2 * f(np.arange(Nt))\n C[0] += 1 # noise\n return scipy.linalg.toeplitz(C)",
... | [
"0.6387653",
"0.6021434",
"0.59131205",
"0.5825419",
"0.57857037",
"0.57784086",
"0.57573915",
"0.567533",
"0.5652715",
"0.5641329",
"0.5636672",
"0.5636672",
"0.56285775",
"0.56064606",
"0.5600935",
"0.55724317",
"0.55433285",
"0.5541137",
"0.5506146",
"0.55005693",
"0.54895... | 0.5629217 | 12 |
Divide the data into trips and give each trip a unique number "trip_no" The data is saved to a parquet file. | def save_numbered_trips(df, output_path:str, max_skip=3):
current_trip_no = 0
parquet_schema = None
if os.path.exists(output_path):
os.remove(output_path)
skips=0
for i,partition in enumerate(df.partitions):
try:
df_raw = partition.compute()
except Val... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_microtrips(self):\n for data in self.microtrip_data:\n file_name = \"../data/microtrips/\" + data.file.name + \"_m\" + \".csv\"\n data.save_csv(file_name)",
"def export_trip_information(trip_id,first_arrive,first_depart,\n trip_length,trip_duration,to... | [
"0.60607815",
"0.5905817",
"0.5816707",
"0.54936224",
"0.53999996",
"0.53608507",
"0.5337857",
"0.53275985",
"0.5279713",
"0.5245389",
"0.52331084",
"0.52224356",
"0.51837873",
"0.5180322",
"0.5174375",
"0.51288676",
"0.5123644",
"0.510983",
"0.51059484",
"0.5104036",
"0.5098... | 0.67602295 | 0 |
bags the data for the specified participants by sessions. The starting index of each session is defined in session_start and the corresponding labels are defined in session_labels. (X,Y) is the entire dataset. | def single_instances_to_sessions(X, Y, session_labels, session_start, participant_indices):
bags = []
labels = []
single_instance_labels = []
for k in participant_indices:
for j in range(len(session_labels[k])):
if j < len(session_labels[k])-1:
end = session_start[k][j+1]
else:
end = len(X[k])
ba... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def regroup_dataset(labels):\r\n batch_y = labels.copy()\r\n for i, label in enumerate(labels):\r\n if label in [0, 15, 19]:\r\n batch_y[i]=0\r\n if label in [1, 2, 3, 4, 5,]:\r\n batch_y[i]=1\r\n if label in [... | [
"0.5448921",
"0.53773844",
"0.5312974",
"0.5291654",
"0.52719367",
"0.52677006",
"0.52605337",
"0.5203306",
"0.51902205",
"0.51698947",
"0.5103194",
"0.50545406",
"0.5038974",
"0.5037716",
"0.50168985",
"0.5003415",
"0.50015026",
"0.4984332",
"0.49801752",
"0.4976352",
"0.494... | 0.6738862 | 0 |
Read a list of synapse admin events and report changes to user power levels. | def report_admin_events(events):
levels = {} # keeps track of user -> level mapping over time
show_mutes = False
for event in events:
(timestamp, sender, event_type, content) = event
print(f"\n{timestamp}\t{sender}")
# report on users where the prior known level is gone
us... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _e_list(self, ctx):\n event_list = self.database.get_guild_events(ctx.guild.id)\n if len(event_list) == 0:\n await ctx.send(\"This server has no custom events\")\n return\n out = \"```\\nServer Events:\\n\"\n for event in event_list:\n out += f... | [
"0.595979",
"0.5520849",
"0.5495647",
"0.5478341",
"0.53156155",
"0.53067887",
"0.52975523",
"0.5295242",
"0.5291212",
"0.52869153",
"0.5238782",
"0.5236966",
"0.52195317",
"0.5198999",
"0.5172369",
"0.51485234",
"0.51476765",
"0.51330614",
"0.51263815",
"0.5109358",
"0.51061... | 0.66740656 | 0 |
Calculates the time difference abs(date1 date2) between two dates in months. Day is neglected. | def month_diff(date1, date2):
# First make sure, that date2 > date1
if date1.daysTo(date2) < 0:
date_tmp = date1
date1 = date2
date2 = date_tmp
years = date2.year() - date1.year()
months = date2.month() - date1.month()
if months < 0:
years -= 1
months += 12
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def diff_month(d1, d2):\n return ceil(abs((d1.year - d2.year) * 12 + d1.month - d2.month))",
"def compute_duration(date1, date2):\n duration = 0\n if date1 and date2:\n delta = abs(date1 - date2)\n duration = delta.days * 86400 + delta.seconds\n return duration",
"def date_diff_months... | [
"0.6941323",
"0.6818145",
"0.679008",
"0.67421985",
"0.6620554",
"0.64680517",
"0.64635617",
"0.64242184",
"0.6399711",
"0.6364292",
"0.60353655",
"0.59266156",
"0.582229",
"0.5665558",
"0.5641006",
"0.5557162",
"0.5533768",
"0.55188507",
"0.55112755",
"0.5487111",
"0.5483864... | 0.7048405 | 0 |
arrival_time = frequency of the exponential distribution related to the arrival time in 1/seconds service_time = deterministic service time in 1/seconds max_time = time of simulation in hour to be converted in seconds in the program | def M_D_1(arrival_time,max_time,service_time=1/90):
#conversion in seconds
max_seconds = max_time*60*60
sim_time = 0.0 # simulation time
t_1 = 0.0 # time for next event (arrival)
t_2 = max_seconds # time for next event (departure)
t_n = 0.0 #last event time--> tempo dell'ultimo avvenimento gener... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def approximate_delivery_time(self):\n # this is set to seconds just of demonstration\n approx_delivery_time = random.randrange(300, 600)\n approx_time_to_main_station = approx_delivery_time / 2\n\n return {\n \"delivery_time\": approx_delivery_time,\n \"time_to_st... | [
"0.623899",
"0.62073016",
"0.57325894",
"0.56798995",
"0.5615627",
"0.5612654",
"0.55865824",
"0.5578292",
"0.55203074",
"0.5509975",
"0.5509975",
"0.54552954",
"0.543938",
"0.5385902",
"0.53795916",
"0.534916",
"0.5277093",
"0.52733487",
"0.5250447",
"0.52468187",
"0.5239847... | 0.69476897 | 0 |
This function/filter reads the host_var information provided by Ansible aruba_config module to extract "changed lines" | def aruba_diff(self, host_var):
output_list = []
for item in host_var:
if type(host_var[item]) is dict:
if 'updates' in host_var[item]:
if host_var[item]['changed']:
update = host_var[item]['updates']
for i i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __analyze_config(self):\n result = {}\n with open(self.file) as f:\n data = f.readlines()\n temp_key = ''\n for line in data:\n if line[0] == '\t' or line[0] == ';':\n result[temp_key].append(line.strip())\n else:\n temp... | [
"0.5730209",
"0.56443113",
"0.5615085",
"0.5516753",
"0.54714805",
"0.5436443",
"0.54273635",
"0.53481036",
"0.5313529",
"0.5283646",
"0.52792495",
"0.5246545",
"0.5220793",
"0.5219981",
"0.52106386",
"0.5179972",
"0.51748455",
"0.51602554",
"0.5153993",
"0.5145902",
"0.51281... | 0.66426724 | 0 |
Training step that optimizes the weights provided some batch_size X and Y examples from the dataset. | def train_batch():
X, Y = train_X, train_Y
feed_dict = {encoder[t]: X[t] for t in range(len(encoder))}
feed_dict.update({labels[t]: Y[t] for t in range(len(labels))})
_, loss_t = sess.run([train_op, loss], feed_dict)
return loss_t | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self, X, y, batch_size=5, num_epochs=10, alpha=0.1, gamma=0.9, learning=\"Delta\"):\r\n for i in range(num_epochs):\r\n bse = 0 \r\n for j in range(X.shape[1]//batch_size):\r\n x_bs = X[:,bse:bse+batch_size]\r\n y_bs = y[:,bse:bse+batch_size]\r\... | [
"0.77232385",
"0.7349785",
"0.707549",
"0.69327986",
"0.69199604",
"0.6844348",
"0.6836232",
"0.68340915",
"0.68285096",
"0.6825701",
"0.6808993",
"0.6807454",
"0.6770575",
"0.6641682",
"0.66391444",
"0.6622418",
"0.6603509",
"0.6600248",
"0.65747213",
"0.6538866",
"0.6527656... | 0.0 | -1 |
Test step, does NOT optimizes. Weights are frozen by not doing sess.run on the train_op. | def test_batch():
X, Y = test_X, test_Y
feed_dict = {encoder[t]: X[t] for t in range(len(encoder))}
feed_dict.update({labels[t]: Y[t] for t in range(len(labels))})
loss_t = sess.run([loss], feed_dict)
return loss_t[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n self._logger = mock_lib.MockBenchmarkLogger()\n\n self.graph = tf.Graph()\n with self.graph.as_default():\n tf.train.create_global_step()\n self.train_op = tf.assign_add(tf.train.get_global_step(), 1)\n self.global_step = tf.train.get_global_... | [
"0.7189777",
"0.713235",
"0.6868056",
"0.6775731",
"0.67507005",
"0.67205113",
"0.66059977",
"0.65993184",
"0.65889955",
"0.65766",
"0.6544388",
"0.65419114",
"0.6527287",
"0.6513407",
"0.648487",
"0.64734393",
"0.64699334",
"0.6458755",
"0.64557123",
"0.644801",
"0.642417",
... | 0.6011905 | 82 |
Creates an empty list instance | def __init__(self):
self._head = None
self._tail = None
self._size = 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def empty_list(*args):\n return []",
"def __init__(self):\n # Initializing an empty list.\n self.mylist = []",
"def new_empty_ll():\n from linked_list import Linked_List\n this_empty_ll = Linked_List()\n return this_empty_ll",
"def __noop_list(self, *args, **kwargs):\n return []"... | [
"0.7383587",
"0.7302276",
"0.72101533",
"0.71087044",
"0.7041304",
"0.7011241",
"0.7011241",
"0.67002696",
"0.66640145",
"0.6652877",
"0.6644676",
"0.6621762",
"0.6608354",
"0.66006655",
"0.654123",
"0.65394247",
"0.64968204",
"0.64968204",
"0.64968204",
"0.6482919",
"0.64398... | 0.0 | -1 |
Gets the length of the list | def __len__(self):
return self._size | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getLength(self):\r\n return len(self.list)",
"def length(self):\n return self.list.length",
"def length(self):\n return self.list.length",
"def get_list_length(self):\r\n return self._api.get_list_length()",
"def length(self):\n return self.list.length()",
"def leng... | [
"0.89645356",
"0.88459057",
"0.88459057",
"0.88405335",
"0.8820714",
"0.8757057",
"0.8654384",
"0.8635413",
"0.86173993",
"0.8571206",
"0.8492897",
"0.8482033",
"0.84651417",
"0.84598345",
"0.84011644",
"0.82260954",
"0.82017213",
"0.81988937",
"0.8151289",
"0.810921",
"0.810... | 0.0 | -1 |
Determines if any target value exists | def __contains__(self, item):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has(self, target):\r\n return target in self.by_target",
"def has(self, target):\n return target in self.by_target",
"def _ok(self, assignment_graph, source, value, target):\n target_values = assignment_graph[target]\n return len(target_values - set([value])) > 0",
"def any(self) ... | [
"0.70388",
"0.69756544",
"0.6831402",
"0.6467504",
"0.6203474",
"0.6096493",
"0.60902774",
"0.60739547",
"0.6044992",
"0.6015043",
"0.60087895",
"0.59799826",
"0.59799826",
"0.596468",
"0.596468",
"0.59619915",
"0.59619915",
"0.59619915",
"0.59619915",
"0.59528977",
"0.594948... | 0.0 | -1 |
Makes the list iterable | def __iter__(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iter__():",
"def __iter__():",
"def __iter__():",
"def __iter__():",
"def __iter__(self):\n return iter(self.to_list())",
"def _build_iterable(self):",
"def __iter__(self):\n return iter(self.atom_list)",
"def __iter__(self):\n raise NotImplementedError(\"__iter__\")",
"d... | [
"0.7771175",
"0.7771175",
"0.7771175",
"0.7771175",
"0.7748262",
"0.7495855",
"0.7493199",
"0.747693",
"0.7387433",
"0.7387433",
"0.7387433",
"0.7387433",
"0.7387433",
"0.7376672",
"0.7362731",
"0.73596007",
"0.7341213",
"0.7341213",
"0.73187697",
"0.7312031",
"0.7312031",
... | 0.7373446 | 19 |
Gets the current head | def head(self):
return self._head | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def first(self):\r\n return self.__head",
"def first(self):\n return self.__head",
"def currenthead(self):\n return self.repo.head.object",
"def peek(self):\n return self.list.head",
"def head(self) -> object:\n if not self._head:\n raise EmptyListException(\"T... | [
"0.80130213",
"0.7923789",
"0.7821768",
"0.75414413",
"0.73890346",
"0.73000383",
"0.7205366",
"0.7202247",
"0.72009563",
"0.71663415",
"0.71562153",
"0.71256787",
"0.710123",
"0.7087479",
"0.7047039",
"0.7027316",
"0.7017254",
"0.69998443",
"0.69862455",
"0.69797623",
"0.697... | 0.85257405 | 1 |
Gets the current tail | def tail(self):
return self._tail | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tail(self):\n return self._readahead.getvalue()",
"def get_tail(self):\n pointer = self.head\n while pointer.next_node:\n pointer = pointer.next_node\n return pointer",
"def peek_last(self):\n if self.is_empty(): raise RuntimeError(\"Empty list\")\n ... | [
"0.7987476",
"0.75084555",
"0.7217858",
"0.7078854",
"0.70251787",
"0.6993961",
"0.69410443",
"0.6919684",
"0.6894651",
"0.68824685",
"0.6878774",
"0.6853597",
"0.68393075",
"0.67811173",
"0.6733288",
"0.6732261",
"0.6592453",
"0.65848786",
"0.65684897",
"0.6545789",
"0.65059... | 0.864701 | 1 |
Gets the list size | def size(self):
return self._size | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def size(self):\n return self.list_size",
"def get_list_length(self):\r\n return self._api.get_list_length()",
"def getSize(self):\r\n list = self.getList()\r\n return len(list)",
"def size(self):\n return len(self.__list)",
"def getLength(self):\r\n return len(sel... | [
"0.90231985",
"0.88729995",
"0.8824647",
"0.86315054",
"0.85967255",
"0.85088795",
"0.8443649",
"0.8432129",
"0.8432129",
"0.84318507",
"0.8413873",
"0.83628243",
"0.8263652",
"0.8254407",
"0.8213345",
"0.8197529",
"0.81928915",
"0.81516874",
"0.8115379",
"0.81023437",
"0.807... | 0.0 | -1 |
Determines the emptiness of the list | def empty(self):
return self._size is 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def empty(self):\n if len(self.list_x) == 0:\n return True\n else:\n return False",
"def filled(self):\n return self.list.count(0) == 0",
"def is_empty(self):\n return self.list_size == 0",
"def is_empty(self):\n return self.list.length == 0",
"def i... | [
"0.80257577",
"0.79700047",
"0.7873327",
"0.78489643",
"0.78489643",
"0.7747847",
"0.7672707",
"0.76688343",
"0.76248163",
"0.7612408",
"0.7558429",
"0.75444674",
"0.74985474",
"0.74538016",
"0.74538016",
"0.7441022",
"0.7439793",
"0.7433452",
"0.7433452",
"0.7421738",
"0.742... | 0.0 | -1 |
Adds a node to the front of the list | def addFront(self, data):
new_list = _Node(data)
temp = self._head
if self._head is None:
self._head = new_list
self._tail = new_list
else:
new_list.next = temp
new_list.next.prev = new_list
self._head = new_list
self._... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def push_front(self, item):\n new_node = Node(item)\n # if the list is empty, make it head\n if self.head is None:\n self.head = new_node\n # else, \n else:\n new_node.next = self.head # new node points to current head\n self.head = new_node # c... | [
"0.82249105",
"0.7810608",
"0.7768546",
"0.7768546",
"0.7755671",
"0.7738799",
"0.77328646",
"0.7720509",
"0.7625948",
"0.7588103",
"0.75430006",
"0.752145",
"0.7492182",
"0.746664",
"0.745477",
"0.7394027",
"0.7339842",
"0.73390335",
"0.73347354",
"0.728799",
"0.7265528",
... | 0.7907306 | 1 |
Return name of serializer for a model. | def get_serializer_name_by_model(_model):
return '{}Serializer'.format(_model.__name__) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_model_name(self) -> str:\n return self._get_string(openvr.Prop_RenderModelName_String)",
"def name(self) -> str: # pragma: no cover\n return self.model.__name__",
"def get_model_name(self) -> str:\n raise NotImplementedError",
"def model_name(self) -> str:\n return self._... | [
"0.6780367",
"0.6774362",
"0.66296005",
"0.6629534",
"0.657652",
"0.6532302",
"0.65118784",
"0.6496903",
"0.64815027",
"0.639073",
"0.63782823",
"0.63662857",
"0.62982553",
"0.6294734",
"0.6262839",
"0.6249802",
"0.6196127",
"0.6195564",
"0.6152502",
"0.6151185",
"0.6149466",... | 0.9127496 | 0 |
Supervised Learning of Universal Sentence Representations from Natural Language Inference Data | def forward(self, source_sentences, target_sentences):
u = self.encoder(source_sentences)
v = self.encoder(target_sentences)
features = torch.cat((u, v, torch.abs(u - v), u * v), 1)
return self.classifier(features) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict_sentences(self, sents):\n tkw=self.tkw\n sents_attr=[]\n sent_samples={\n \"word_inputs\":[],\n \"predicate_inputs\":[],\n \"postags_inputs\":[]\n }\n print('prepare data')\n for sid,sent in enumerate(sents):\n if sid... | [
"0.6346211",
"0.63405776",
"0.6338936",
"0.63327533",
"0.62454486",
"0.6228956",
"0.6184826",
"0.618037",
"0.617182",
"0.61669314",
"0.61542684",
"0.61505806",
"0.61445844",
"0.61279905",
"0.6127771",
"0.61258423",
"0.61200845",
"0.6100256",
"0.60922563",
"0.60849583",
"0.608... | 0.0 | -1 |
A text classification network made w/ the goal of creating sentence embeddings. | def forward(self, source_sentences):
return self.classifier(self.encode(source_sentences)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def classify(text):\n # TODO Wonder if there's a better way of doing this so the model persists across fucn calls. Will see once I get\n # Heroku running\n\n sentences = sent_tokenize(text)\n clean_sentences = list(map(clean_text, sentences))\n word_tokenizer = BertTokenizerFast.from_pretrained('be... | [
"0.7100394",
"0.6748437",
"0.65471923",
"0.6498375",
"0.6481639",
"0.64756286",
"0.64739716",
"0.64437383",
"0.6409879",
"0.6400079",
"0.63984555",
"0.6376186",
"0.63573384",
"0.63420796",
"0.63091457",
"0.6302174",
"0.6277894",
"0.6258807",
"0.6257803",
"0.6256364",
"0.62519... | 0.0 | -1 |
Verify that we can respect all the documented containers names possible | def test_object_names_container(sdc_builder, sdc_executor, azure, container_name_category, index):
container_name = container_name_category
event_hub_name = get_random_string(string.ascii_lowercase, 10)
builder = sdc_builder.get_pipeline_builder()
azure_iot_event_hub_consumer = builder.add_stage(name=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validateName(name):\n return name in [container.name for container in DOCKER_CLIENT.containers.list()]",
"def test_basic(self):\n self.check_4_way('container', 'pod')",
"def test_index_containers(self):\n pass",
"def test_containers(self):\n\n message = {\"method\": \"containers\"... | [
"0.6736741",
"0.6729749",
"0.60338986",
"0.59777915",
"0.5967935",
"0.59532505",
"0.5937677",
"0.5929508",
"0.58507514",
"0.5833313",
"0.58174473",
"0.57982504",
"0.5780771",
"0.57688516",
"0.5733226",
"0.5706515",
"0.5678251",
"0.5677904",
"0.5676172",
"0.5647392",
"0.562660... | 0.0 | -1 |
Verify that we can respect all the documented containers names possible | def test_object_names_blob(sdc_builder, sdc_executor, azure, blob_name_category, index):
container_name = get_random_string(string.ascii_lowercase, 10)
event_hub_name = blob_name_category
builder = sdc_builder.get_pipeline_builder()
azure_iot_event_hub_consumer = builder.add_stage(name=AZURE_IOT_EVENT... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validateName(name):\n return name in [container.name for container in DOCKER_CLIENT.containers.list()]",
"def test_basic(self):\n self.check_4_way('container', 'pod')",
"def test_index_containers(self):\n pass",
"def test_containers(self):\n\n message = {\"method\": \"containers\"... | [
"0.67369556",
"0.67299783",
"0.60355276",
"0.5980367",
"0.5968923",
"0.5954608",
"0.5939962",
"0.59322596",
"0.5850188",
"0.5835206",
"0.58177173",
"0.5800159",
"0.57798576",
"0.57688797",
"0.57336664",
"0.57085073",
"0.56805813",
"0.5678986",
"0.5676663",
"0.56491464",
"0.56... | 0.0 | -1 |
Test read multiple batches. | def test_multiple_batch(sdc_builder, sdc_executor, azure, number_batches):
container_name = get_random_string(string.ascii_lowercase, 10)
event_hub_name = get_random_string(string.ascii_lowercase, 10)
number_records = 1000
builder = sdc_builder.get_pipeline_builder()
azure_iot_event_hub_consumer ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_batch(self):\n pass",
"def test_batch_read_all_bins_pos(self):\n\n b = br.Read((\"test\", \"demo\", 1), ops=None, read_all_bins=True)\n\n assert b.read_all_bins",
"def test_block_missing_batch(self):\n pass",
"def test_block_batches_order(self):\n pass",
"def tes... | [
"0.7609623",
"0.6662145",
"0.6534062",
"0.6469143",
"0.63781834",
"0.63687474",
"0.633586",
"0.63011676",
"0.6233108",
"0.622242",
"0.6204284",
"0.619079",
"0.61579096",
"0.61227316",
"0.60985446",
"0.6091486",
"0.6060122",
"0.6053497",
"0.6049608",
"0.6037472",
"0.6037338",
... | 0.6025853 | 23 |
Test Azure EventHub origin parses Binary in a variety of data types. | def test_data_format_binary(sdc_builder, sdc_executor, azure):
container_name = get_random_string(string.ascii_lowercase, 10)
event_hub_name = get_random_string(string.ascii_lowercase, 10)
MESSAGES = [b'message 1', b'message 2']
EXPECTED_OUTPUT = "[b'message 1', b'message 2']"
builder = sdc_builde... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_bytes(self, ???):",
"def test_bin_data_type(self):\n\n with pytest.raises(TypeError) as verr:\n avg.median2D(self.testInst, ['1', 'a', '23', '10'], 'longitude',\n ['0', 'd', '24', 'c'], 'mlt',\n ['dummy1', 'dummy2', 'dummy3'], auto_bin=Fa... | [
"0.6008974",
"0.59854835",
"0.5940457",
"0.5918118",
"0.5896898",
"0.5895602",
"0.5882247",
"0.58684736",
"0.58602846",
"0.58145744",
"0.5814127",
"0.57945067",
"0.5786584",
"0.57704145",
"0.57686555",
"0.57686555",
"0.57686555",
"0.57686555",
"0.57686555",
"0.57686555",
"0.5... | 0.6982023 | 0 |
Azure EventHub origin parses JSON in a variety of data types. | def test_data_format_json(sdc_builder, sdc_executor, azure, data_type):
container_name = get_random_string(string.ascii_lowercase, 10)
event_hub_name = get_random_string(string.ascii_lowercase, 10)
# We map data_type to input data as well as the expected output.
DATA_TYPE = {'ARRAY': ['Alex', 'Xavi'],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_event_payload(event):\n payload_key = 'event' if 'event' in event else 'data'\n if payload_key in event and isinstance(event[payload_key], str):\n event = event.copy()\n try:\n event[payload_key] = json.loads(event[payload_key])\n except ValueError:\n pass... | [
"0.6673187",
"0.6324516",
"0.62787443",
"0.62350726",
"0.6046042",
"0.5893333",
"0.58861136",
"0.5836435",
"0.5807699",
"0.5807676",
"0.58076185",
"0.58072615",
"0.5800543",
"0.58004636",
"0.57962376",
"0.5793326",
"0.5781644",
"0.57799",
"0.57798296",
"0.5779329",
"0.5742935... | 0.5784067 | 16 |
Azure EventHub origin parses Text in a variety of data types. | def test_data_format_text(sdc_builder, sdc_executor, azure):
container_name = get_random_string(string.ascii_lowercase, 10)
event_hub_name = get_random_string(string.ascii_lowercase, 10)
MESSAGE = 'Hello World!'
EXPECTED = {'text': 'Hello World!'}
builder = sdc_builder.get_pipeline_builder()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_textAsEvent(self):\n self.assertEquals(\n textAsEvent(u\"Hello, World!\"),\n b\"data: Hello, World!\\n\\n\"\n )",
"def parse_string(self, data):\n pass",
"def from_text(cls, text):\n raw = json.loads(text)\n event_msg = EventMessage.from_text(ra... | [
"0.6361389",
"0.61759293",
"0.61751777",
"0.6019956",
"0.5999681",
"0.5953749",
"0.59506565",
"0.59049666",
"0.577963",
"0.5729194",
"0.5720689",
"0.55496836",
"0.5544985",
"0.5542114",
"0.5516061",
"0.5498533",
"0.54913414",
"0.5472944",
"0.54333293",
"0.5430793",
"0.5406387... | 0.5179421 | 46 |
Create and return a Azure EventHub origin stage depending on execution mode for the pipeline. | def _get_azure_eventhub_consumer_stage(builder, container_name, event_hub_name, data_format):
azure_iot_event_hub_consumer = builder.add_stage(name=AZURE_IOT_EVENT_HUB_STAGE_NAME).set_attributes(
container_name=container_name,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_event(trigger, event):\n\n if trigger == \"eval\":\n print(\"Triggered by Invoke\")\n\n # event is the pipeline, provide consistent pipeline defaults\n pipeline = default_pipeline(event)\n\n return pipeline\n\n elif trigger == \"S3\":\n print(\"Triggered from S3\"... | [
"0.52332556",
"0.5193338",
"0.5114489",
"0.50379026",
"0.4959821",
"0.48886234",
"0.4858949",
"0.48461798",
"0.4842308",
"0.4800151",
"0.4778661",
"0.47242874",
"0.47108313",
"0.4688939",
"0.4656326",
"0.46418527",
"0.46377864",
"0.45985177",
"0.45866713",
"0.45585388",
"0.45... | 0.62307066 | 0 |
Test that using multithreaded pipeline we can start our pipeline multiple times adding more objects in between without reading any duplicated record neither missing them. | def test_multithreading(sdc_builder, sdc_executor, azure, max_threads):
container_name = get_random_string(string.ascii_lowercase, 10)
event_hub_name = get_random_string(string.ascii_lowercase, 10)
builder = sdc_builder.get_pipeline_builder()
azure_iot_event_hub_consumer = builder.add_stage(name=AZURE... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def producer(pipeline):\n\n for index, iteration in enumerate(range(10)):\n obj = random.randint(1, 101)\n logging.info(\"Producer %s: produced object %s\", index, obj)\n logging.debug(\"Producer %s: about to acquire lock\", index)\n pipeline._lock.acquire()\n pipeline.shift(o... | [
"0.62404513",
"0.61196893",
"0.607896",
"0.607896",
"0.605554",
"0.60008496",
"0.5892256",
"0.587391",
"0.5838322",
"0.5835361",
"0.583378",
"0.5813028",
"0.57524157",
"0.5748982",
"0.57474613",
"0.5741296",
"0.5739111",
"0.5707681",
"0.57005924",
"0.5679863",
"0.56795543",
... | 0.52362895 | 91 |
Test that we can start our pipeline multiple times without reading any duplicated record neither missing them. | def test_resume_offset(sdc_builder, sdc_executor, azure):
container_name = get_random_string(string.ascii_lowercase, 10)
event_hub_name = get_random_string(string.ascii_lowercase, 10)
builder = sdc_builder.get_pipeline_builder()
azure_iot_event_hub_consumer = builder.add_stage(name=AZURE_IOT_EVENT_HUB... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_duplicate_entries(self):",
"def test_getting_state_parallel(self):\n no_replicates = 25\n replicate(experiment2, no_replicates, parallel=True, no_processes=2)\n for i in range(no_replicates):\n self.assertNotIn(SUBSTATE_KEY_PATTERN % i + '.result', state)",
"def test_mo... | [
"0.6436138",
"0.6180809",
"0.61560345",
"0.6148749",
"0.6031402",
"0.6030519",
"0.59612024",
"0.5926448",
"0.5896942",
"0.58900166",
"0.58820057",
"0.58755946",
"0.5870928",
"0.5866555",
"0.584371",
"0.58427185",
"0.58296657",
"0.58072215",
"0.5799708",
"0.5777461",
"0.577661... | 0.0 | -1 |
Test whether we can add a landing page to campaign. | def testAddLandingPageToCampaign(self):
if self.__class__.campaign1 is None:
self.testSaveCampaign()
landing_page = {
'id': '-1',
'url': 'http://www.example.com',
'name': 'Landing page #%s' % Utils.GetUniqueName()
}
self.assert_(isinstance(self.__class__.service.AddLandingP... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def available(self):\n existing_url = self.context.get_personal_fundraising_campaign_url()\n same = existing_url == self.context.absolute_url()\n creating = 'create-personal-campaign-page' in self.request.URL\n return not same and not creating",
"def testGetLandingPagesForCampaign(sel... | [
"0.7193204",
"0.6475577",
"0.63865",
"0.6113079",
"0.5993139",
"0.5958102",
"0.58199036",
"0.5775793",
"0.57187057",
"0.56757647",
"0.56338835",
"0.5573666",
"0.5542688",
"0.55141956",
"0.5502747",
"0.5437384",
"0.5427393",
"0.5408094",
"0.5405026",
"0.539166",
"0.5384252",
... | 0.6654128 | 1 |
Test whether we can copy campaigns. | def testCopyCampaigns(self):
if self.__class__.campaign1 is None:
self.testSaveCampaign()
requests = [{
'campaignId': self.__class__.campaign1['id']
}]
self.assert_(isinstance(self.__class__.service.CopyCampaigns(requests),
tuple)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def canShare(self):\n return False",
"def CanCopy(self):\n return self.HasSelection()",
"def can_be_collected(self):\n return True",
"def canCreateCaddyManip(*args, **kwargs)->bool:\n pass",
"def _copyDataSetsForExperiment(self):\n\n # Copy all tubes - if they could not be co... | [
"0.60453284",
"0.5922676",
"0.5760109",
"0.5710391",
"0.5692238",
"0.5674369",
"0.56590486",
"0.553042",
"0.54061353",
"0.5337865",
"0.5293677",
"0.5285584",
"0.5263262",
"0.52472526",
"0.52441347",
"0.52295303",
"0.52201074",
"0.5219359",
"0.52088076",
"0.520511",
"0.5189243... | 0.7094511 | 0 |
Test whether we can delete a campaign. | def testDeleteCampaign(self):
if self.__class__.campaign2 is None:
self.testSaveCampaign()
self.assertEqual(self.__class__.service.DeleteCampaign(
self.__class__.campaign2['id']), None) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_campaign_by_admin_passes(self):\n response = self.client.delete(\n f\"{self.endpoint_url}{self.test_campaign.id}/\",\n headers={\"Authorization\": self.admin_token},\n )\n response_body = response.get_json()\n self.assertEqual(response.status_code, ... | [
"0.7160737",
"0.6712778",
"0.66537017",
"0.6412838",
"0.6403892",
"0.6248027",
"0.62260723",
"0.6173202",
"0.61620015",
"0.61620015",
"0.6158001",
"0.6153437",
"0.61174256",
"0.61138195",
"0.60950786",
"0.606821",
"0.60502833",
"0.60258365",
"0.59846985",
"0.59573454",
"0.591... | 0.6538772 | 3 |
Test whether we can fetch a campaign. | def testGetCampaign(self):
if self.__class__.campaign1 is None:
self.testSaveCampaign()
self.assert_(isinstance(self.__class__.service.GetCampaign(
self.__class__.campaign1['id']), tuple)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_if_can_fetch(self, url, useragent=\"*\"):\n logger.debug(\"Checking if can fetch %s\" % url)\n return self.rp.can_fetch(useragent=useragent, url=url)",
"def can_fetch(self, agent, url):\n if not url.startswith(self.base_url):\n url = urljoin(self.base_url, url)\n ... | [
"0.6951294",
"0.66682565",
"0.6388986",
"0.6277096",
"0.6162821",
"0.6039939",
"0.5521341",
"0.5516752",
"0.5443673",
"0.5427626",
"0.53725314",
"0.5343013",
"0.53338003",
"0.53287655",
"0.5325066",
"0.5308681",
"0.5290137",
"0.5257859",
"0.52291495",
"0.52203906",
"0.5171033... | 0.61979556 | 4 |
Test whether we can fetch campaigns by criteria. | def testGetCampaignsByCriteria(self):
criteria = {
'archiveFilter': {
'inactiveOnly': 'true'
}
}
self.assert_(isinstance(self.__class__.service.GetCampaignsByCriteria(
criteria), tuple)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_existent_campaigns_returns_campaigns_list(self):\n test_campaign = return_canned_campaign()\n test_campaign.create()\n response = self.client.get(self.endpoint_url)\n response_body = response.get_json()\n self.assertEqual(response.status_code, 200)\n self.asse... | [
"0.6126352",
"0.60831",
"0.5854207",
"0.5814784",
"0.5765778",
"0.5627458",
"0.5505774",
"0.54764736",
"0.5463633",
"0.53875184",
"0.5286463",
"0.5152078",
"0.51443475",
"0.51261663",
"0.509484",
"0.50877887",
"0.5074913",
"0.50539947",
"0.50416815",
"0.50400865",
"0.5023619"... | 0.6735202 | 0 |
Test whether we can fetch landing pages for a campaign. | def testGetLandingPagesForCampaign(self):
if self.__class__.campaign1 is None:
self.testSaveCampaign()
self.assert_(isinstance(self.__class__.service.GetLandingPagesForCampaign(
self.__class__.campaign1['id']), tuple)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def available(self):\n existing_url = self.context.get_personal_fundraising_campaign_url()\n same = existing_url == self.context.absolute_url()\n creating = 'create-personal-campaign-page' in self.request.URL\n return not same and not creating",
"def test_contact_landing_success(self)... | [
"0.67742693",
"0.6306628",
"0.62808394",
"0.6120006",
"0.59452415",
"0.57627016",
"0.5738992",
"0.5561723",
"0.5556827",
"0.55112934",
"0.54937756",
"0.54576766",
"0.5449263",
"0.542853",
"0.54040414",
"0.53753954",
"0.53047925",
"0.53038776",
"0.5275955",
"0.5274629",
"0.526... | 0.67377996 | 1 |
Test whether we can create a campaign. | def testSaveCampaign(self):
self.testSaveLandingPage()
dt = datetime.datetime.now()
campaign = {
'advertiserId': self.__class__.advertiser_id,
'archived': 'false',
'name': 'Campaign #%s' % Utils.GetUniqueName(),
'defaultLandingPageId': self.__class__.landing_page_id,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_campaign(self):\n campaign = self.campaign\n\n self.assertTrue(isinstance(campaign, Campaign))\n self.assertEqual(campaign.name, \"Test Campaign\")",
"def test_create_already_existing_campaign_fails(self):\n test_campaign = return_canned_campaign()\n self.test_o... | [
"0.7282776",
"0.6861378",
"0.6769927",
"0.6562641",
"0.6446506",
"0.64025927",
"0.63065374",
"0.62620866",
"0.61669487",
"0.61126655",
"0.6082157",
"0.60696846",
"0.60404605",
"0.5802044",
"0.5785592",
"0.5767152",
"0.5753982",
"0.5717169",
"0.5715338",
"0.5704595",
"0.567379... | 0.52247524 | 54 |
Test whether we can create a landing page. | def testSaveLandingPage(self):
landing_page = {
'url': 'http://www.example.com',
'name': 'Landing page #%s' % Utils.GetUniqueName()
}
landing_page = self.__class__.service.SaveLandingPage(landing_page)
self.__class__.landing_page_id = landing_page[0]['id']
self.assert_(isinstance(lan... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_landing_page(self):\n # Create a test client\n client = server.app.test_client()\n\n # Use the test client to make requests\n result = client.get('/', follow_redirects=True)\n\n # Compare result.data with assert method\n self.assertIn(b'<p class=\"navbar-text\">Al... | [
"0.6737651",
"0.6642092",
"0.6532604",
"0.63541234",
"0.63539374",
"0.62464356",
"0.62459445",
"0.62454194",
"0.62132585",
"0.62077016",
"0.618775",
"0.6178662",
"0.61785996",
"0.61771363",
"0.6166073",
"0.6118469",
"0.6086317",
"0.60613596",
"0.60205966",
"0.59654224",
"0.59... | 0.0 | -1 |
Updating of product qty | def ProcessOrder(product_id):
product = Product.query.filter_by(product_id = product_id)
if (product):
product.qty = product
db.session.commit() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, product, qty):\n product_id = str(product)\n if product_id in self.basket:\n self.basket[product_id]['qty'] = qty\n self.save()",
"def update(self, product, qty):\n product_id = str(product)\n if product_id in self.cart:\n self.cart[produc... | [
"0.82021457",
"0.7991138",
"0.73357517",
"0.7190872",
"0.71537274",
"0.6928786",
"0.68572164",
"0.68549824",
"0.67613435",
"0.6734073",
"0.668889",
"0.6671283",
"0.6603879",
"0.65982896",
"0.65982896",
"0.6587045",
"0.65754604",
"0.65699196",
"0.65018183",
"0.6474085",
"0.645... | 0.66913927 | 10 |
Render home page of the site | def homepage():
return render_template("home/index.html", title="Welcome") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_home():\r\n\treturn render_template(\"index.html\")",
"def home():\n\n return render_template('home_page.html')",
"def home():\n return render_template('homepage.html')",
"def homepage():\n return render_template(\"home/index.html\")",
"def homepage():\n return render_template('home/... | [
"0.8892464",
"0.8681746",
"0.868129",
"0.85841256",
"0.8567517",
"0.8564356",
"0.8539393",
"0.8536602",
"0.8536602",
"0.8527715",
"0.85203385",
"0.8516136",
"0.8516136",
"0.8516136",
"0.8516136",
"0.8516136",
"0.8516136",
"0.8516136",
"0.8516136",
"0.8516136",
"0.8516136",
... | 0.85693485 | 4 |
Render landing page after successfull login | def dashboard():
return render_template("home/dashboard.html", title="Dashboard") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def landing():\n if g.user:\n return render_template('landing.html', user=g.user)\n return redirect(url_for('login'))",
"def index(self):\n\n # try and pull the user's data\n user = get_active_user_data()\n\n if not user:\n # they are not logged in give them the login... | [
"0.81607425",
"0.7835049",
"0.7612851",
"0.759617",
"0.75545955",
"0.75486267",
"0.7532583",
"0.7532583",
"0.7517395",
"0.74704564",
"0.7379486",
"0.7360537",
"0.7352043",
"0.73301697",
"0.7329643",
"0.7309229",
"0.729956",
"0.728683",
"0.7285191",
"0.727541",
"0.7249322",
... | 0.0 | -1 |
To render admin dashboard | def admin_dashboard():
if current_user.is_admin:
return render_template("home/admin_dashboard.html", title="Admin Dashboard")
abort(403) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dashboard():\n return render_template(\"admin/dashboard.html\", title=\"Dashboard\")",
"def show_admin():\n return render_admin_page(\"admin.html\")",
"def admin():\n return Response(render_template('admin.html'))",
"def dashboard():",
"def index(self):\n return self.render(\"admin/inde... | [
"0.8648089",
"0.8191513",
"0.80940354",
"0.7911078",
"0.7859473",
"0.7806951",
"0.77863497",
"0.7742015",
"0.7731237",
"0.75979704",
"0.7586668",
"0.75291425",
"0.7436194",
"0.7365606",
"0.7362157",
"0.73533463",
"0.7312894",
"0.725193",
"0.7224566",
"0.7199894",
"0.7161485",... | 0.82224727 | 1 |
Display name of the DNS Zone. | def display_name(self) -> Optional[str]:
return pulumi.get(self, "display_name") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def zone_name(self):\n return self._zone_name",
"def name(self):\n return f\"{self.zone_name} {self.zone_variable}\"",
"def name(self) -> str | None:\n if self.zone.GroupName is not None:\n return self.zone.GroupName\n\n return self.zone.Name",
"def name(self) -> str:\n... | [
"0.76426804",
"0.74550986",
"0.7064773",
"0.6893803",
"0.68507403",
"0.6842008",
"0.6833507",
"0.6787723",
"0.6689961",
"0.6662626",
"0.66411114",
"0.65904385",
"0.65904385",
"0.65896606",
"0.65858406",
"0.65848696",
"0.6580685",
"0.6498563",
"0.6498563",
"0.6498563",
"0.6498... | 0.6087911 | 72 |
DNS Server IP array of the DNS Zone. | def dns_server_ips(self) -> Optional[Sequence[str]]:
return pulumi.get(self, "dns_server_ips") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ip_addresses(self):\n try:\n return socket.gethostbyaddr(self.fqdn)[-1]\n except socket.error as _:\n return ['127.0.0.1']",
"def get_server_ip(self, server_id):\n interface_list = self.get_server_ip_mac(server_id)\n if not isinstance(interface_list, list):\n... | [
"0.6982518",
"0.6663064",
"0.6639232",
"0.6582995",
"0.65587693",
"0.64883596",
"0.64526194",
"0.6438488",
"0.6390472",
"0.6310422",
"0.6257167",
"0.6109224",
"0.60959417",
"0.60855275",
"0.6008593",
"0.5972465",
"0.5970295",
"0.59657687",
"0.59450984",
"0.5930674",
"0.59133"... | 0.7367935 | 0 |
Number of DNS Services using the DNS zone. | def dns_services(self) -> Optional[float]:
return pulumi.get(self, "dns_services") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_servos(self) -> int:\n return self._num_servos",
"def service_count(self) -> str:\n return pulumi.get(self, \"service_count\")",
"def get_new_service_num(route53_zone, service_name):\n\n # Match records belonging to the service for particular service and\n # environment.\n match_... | [
"0.6881554",
"0.65291023",
"0.6471647",
"0.63960993",
"0.62855804",
"0.6134902",
"0.61287624",
"0.60777795",
"0.600986",
"0.60090524",
"0.6004223",
"0.5980317",
"0.5954924",
"0.5919003",
"0.58260965",
"0.581609",
"0.58124703",
"0.5804332",
"0.579322",
"0.5773976",
"0.5755711"... | 0.6778599 | 1 |
Domain names of the DNS Zone. | def domain(self) -> Optional[Sequence[str]]:
return pulumi.get(self, "domain") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_domain_names(self) -> Dict:\n pass",
"def list_domain_names():\n pass",
"def zone_names(domain):\n fragments = domain.split('.')\n return ['.'.join(fragments[i:]) for i in range(0, len(fragments))]",
"def get_dns_list(self):\n return self.get_ipv4_dns_list()",
"def list_zone... | [
"0.8048088",
"0.7856697",
"0.7513482",
"0.74956244",
"0.74465716",
"0.73392856",
"0.7316214",
"0.72221154",
"0.72098655",
"0.7192537",
"0.7182453",
"0.7060481",
"0.7050362",
"0.7015216",
"0.6959108",
"0.6945479",
"0.6894981",
"0.6887697",
"0.68169963",
"0.6804438",
"0.6753850... | 0.6229096 | 59 |
Source IP of the DNS Zone. | def source_ip(self) -> Optional[str]:
return pulumi.get(self, "source_ip") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSourceIp(self):\n return self.__sourceIp",
"def getOriginIp(self):\n return self.originIp",
"def public_ip_source(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"public_ip_source\")",
"def address(self):\n \n return self.__ip",
"def ip_address(self) ... | [
"0.73396534",
"0.6806294",
"0.6775697",
"0.6729144",
"0.669053",
"0.66422296",
"0.66422296",
"0.66401964",
"0.6604399",
"0.6597317",
"0.65907013",
"0.6536555",
"0.6487871",
"0.6486956",
"0.64785546",
"0.64755166",
"0.64685756",
"0.6462598",
"0.6390518",
"0.6390518",
"0.638882... | 0.752894 | 0 |
Function takes in an input of a specific xml string with surrounding instructions tags and returns a valid html string. | def test_get_instructions(self):
xmltree = etree.fromstring(self.sample_xml)
expected_xml = "<div><p>Helper Test Instructions.</p></div>"
actual_xml = get_instructions(xmltree)
assert actual_xml is not None
assert expected_xml.strip() == actual_xml.strip()
xmltree = etr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xml(string, token=[WORD, POS, CHUNK, PNP, REL, ANCHOR, LEMMA]):\n return Text(string, token).xml",
"def html(input):\n output=atpic.cleaner_alex.clean(input)\n return output",
"def get_html(self):\r\n # TODO: why are there nested html tags here?? Why are there html tags at all, in fact?\r\... | [
"0.617261",
"0.6098834",
"0.5746285",
"0.5708064",
"0.56590945",
"0.55680555",
"0.5534447",
"0.55276144",
"0.5519618",
"0.5502098",
"0.5476914",
"0.5361028",
"0.5359617",
"0.5358282",
"0.53365433",
"0.5336395",
"0.5330039",
"0.5326488",
"0.5319277",
"0.53137803",
"0.53066504"... | 0.5628138 | 5 |
Tests whether given a url if the video will return a youtube source or extension | def test_get_extension(self):
expectedyoutube = 'video/youtube'
expectednotyoutube = 'video/mp4'
result1 = get_extension(self.sample_sourceurl)
result2 = get_extension(self.sample_youtubeurl)
assert expectedyoutube == result2
assert expectednotyoutube == result1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isYouTube(self):\n if 'youtube' in self.link.split('.'):\n return True\n return None",
"def check_url(url=None, parse_url=None):\n \n if not parse_url:\n if url:\n parse_url = urlparse.urlparse(url)\n \n #yt_domains = ['youtube.com', 'youtube-n... | [
"0.788234",
"0.7384367",
"0.72096467",
"0.7126284",
"0.6865806",
"0.67937374",
"0.6791887",
"0.67800224",
"0.67411244",
"0.6726512",
"0.6726139",
"0.660549",
"0.65651995",
"0.65489876",
"0.65404326",
"0.65394735",
"0.6538381",
"0.6473086",
"0.6471275",
"0.6445513",
"0.6442236... | 0.67213124 | 11 |
Run the main functionality of the program | def main():
db_config_params = config.get_db_config('psql')
print(f'Connecting to {db_config_params["database"]} database.')
try:
# Will commit and close the connection
with psycopg2.connect(**db_config_params) as connection:
with connection.cursor() as cursor:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n run_program()",
"def run():\n main()",
"def main():\n print(\"is Running!\")",
"def main():\n return",
"def main():\n\n BASIC.run(PROGRAM)",
"def main():\n pass",
"def run_main():\n main(sys.argv)",
"def main():\n print(\"Call your main application code here\")... | [
"0.8905815",
"0.8603472",
"0.82622087",
"0.82094646",
"0.8201298",
"0.81621265",
"0.8152863",
"0.80915654",
"0.80915654",
"0.80915654",
"0.80447954",
"0.8030121",
"0.80230725",
"0.80230725",
"0.80230725",
"0.80230725",
"0.80230725",
"0.80230725",
"0.80230725",
"0.80230725",
"... | 0.0 | -1 |
The main entrypoint of the resume web application. | def home():
now_dt = dt.datetime.now()
return render_template(
'resume/home.html',
age=relativedelta(now_dt, dt.datetime(day=19, month=3, year=1983)).years,
current_year=now_dt.year,
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resume():\n return render_template('/resume.html')",
"def startapp():",
"def main():\n print(\"def main\")\n return APP.run()",
"def main():\n app = App()\n app.run()",
"def main():\n\n # this part of the program opens student txt resume and detects key info\n\n # sets the name of resu... | [
"0.6950655",
"0.65195596",
"0.64208555",
"0.64051366",
"0.6387563",
"0.6358651",
"0.6345297",
"0.63428",
"0.6320092",
"0.63030446",
"0.6287019",
"0.62853336",
"0.6278611",
"0.6262163",
"0.62319463",
"0.6134304",
"0.6091628",
"0.60407025",
"0.60370904",
"0.60318667",
"0.603186... | 0.0 | -1 |
The main entrypoint of the resume web application. | def details():
now_dt = dt.datetime.now()
return render_template(
'resume/home.html',
age=relativedelta(now_dt, dt.datetime(day=19, month=3, year=1983)).years,
current_year=now_dt.year,
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resume():\n return render_template('/resume.html')",
"def startapp():",
"def main():\n print(\"def main\")\n return APP.run()",
"def main():\n app = App()\n app.run()",
"def main():\n\n # this part of the program opens student txt resume and detects key info\n\n # sets the name of resu... | [
"0.6950586",
"0.6519517",
"0.6420699",
"0.6405276",
"0.6387574",
"0.635867",
"0.63456076",
"0.63422334",
"0.6320472",
"0.6303545",
"0.6287705",
"0.6285776",
"0.62785864",
"0.62617797",
"0.62316823",
"0.61350286",
"0.6092063",
"0.6040754",
"0.6037207",
"0.6031369",
"0.6031369"... | 0.0 | -1 |
The main entrypoint of the resume web application. | def download():
now_dt = dt.datetime.now()
return render_template(
'resume/home.html',
age=relativedelta(now_dt, dt.datetime(day=19, month=3, year=1983)).years,
current_year=now_dt.year,
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resume():\n return render_template('/resume.html')",
"def startapp():",
"def main():\n print(\"def main\")\n return APP.run()",
"def main():\n app = App()\n app.run()",
"def main():\n\n # this part of the program opens student txt resume and detects key info\n\n # sets the name of resu... | [
"0.6950586",
"0.6519517",
"0.6420699",
"0.6405276",
"0.6387574",
"0.635867",
"0.63456076",
"0.63422334",
"0.6320472",
"0.6303545",
"0.6287705",
"0.6285776",
"0.62785864",
"0.62617797",
"0.62316823",
"0.61350286",
"0.6092063",
"0.6040754",
"0.6037207",
"0.6031369",
"0.6031369"... | 0.0 | -1 |
Creates a text file which contains a short summary of the dataset_dict data | def write_analysis(path, dataset_dict, datasettype, mask_part, start_time, supervised=True):
for mask_el in mask_part:
if mask_el == 'podocytes':
filename = datasettype + '_podos.txt'
filestr = 'podos images'
elif mask_el == 'glomerulus':
filename = datasettype + ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_simple_report(final_dictionary):\n otpt = open('multifind_simple_summary.txt', 'w')\n for cat in final_dictionary:\n category_name = cat[0]\n category_cont = str(len(cat[1]))\n otpt.write(category_name + ' ')\n otpt.write(category_cont + '\\n')\n otpt.close()",
"... | [
"0.72692883",
"0.70404285",
"0.65547776",
"0.6458474",
"0.64352334",
"0.631799",
"0.6294561",
"0.62730587",
"0.6229788",
"0.62266004",
"0.61721945",
"0.60947776",
"0.6037688",
"0.60162705",
"0.59921813",
"0.5952756",
"0.5932814",
"0.59305197",
"0.5919714",
"0.59086657",
"0.58... | 0.5494341 | 65 |
Creates a pandas dataframe containing the analysis of mask and prediction | def write_dataframe(path, dataset_dict, image_list, datasettype, mask_part):
for mask_el in mask_part:
titles = []
for i in range(len(image_list)):
# Get rid of .tif and the path before
image_name = os.path.split(image_list[i])[1]
titles.append(image_name[:-4])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prediction_features(prediction_data: pd.DataFrame):\n return pd.get_dummies(\n prediction_data.drop(columns=[\"outstanding_balance\", \"status\", \"account_no\"])\n )",
"def get_srs_features(df):\n\n #test result classified by labels\n li = df.TestResultsCode.tolist()\n labels = [ item... | [
"0.58400506",
"0.58308923",
"0.57699585",
"0.56826246",
"0.56474906",
"0.5641397",
"0.5617641",
"0.556883",
"0.5511037",
"0.5510878",
"0.54680425",
"0.54326487",
"0.5415884",
"0.5394611",
"0.5394532",
"0.5381576",
"0.5379836",
"0.53677845",
"0.53350216",
"0.53309435",
"0.5330... | 0.0 | -1 |
Creates the csv output which will be used for the classification. Dataframe contains optionally the WT1 signal of the glomerulus prediction, the DACH1 signal for the podocoyte prediction and the stereological calculations. | def write_readouts(path, dataset_dict, image_list, datasettype, mask_part,
do_wt1_signal, do_dach1_signal, do_stereology_pred, do_stereology_gt):
titles = []
for i in range(len(image_list)):
image_name = os.path.split(image_list[i])[1]
titles.append(image_name[:-4])
# Se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __create_output_csv(self, df, score_list, elapsed_list):\n df['Similar']=score_list\n df['Elapsed']=elapsed_list\n df.to_csv('Output.csv',index=False)\n return df",
"def create_model_csv(self):\n\n self.model_df.to_csv(self.model_output_file)",
"def classification_report(... | [
"0.6866416",
"0.67374027",
"0.6438249",
"0.6316223",
"0.6306237",
"0.6122821",
"0.6075931",
"0.6042094",
"0.6034793",
"0.6025147",
"0.60183454",
"0.6013684",
"0.5995917",
"0.5989906",
"0.5972817",
"0.59266",
"0.5921068",
"0.5904744",
"0.5889595",
"0.5854905",
"0.58439815",
... | 0.0 | -1 |
As a general rule you should ensure there's an appropriate index for the field provided in ordering. allow_count (default False) indicates whether or not to allow count queries that can be extremely expensive on large and fast changing datasets. allow_empty_first_page and orphans are currently ignored and only exist to... | def __init__(
self,
queryset,
per_page=25,
ordering="pk",
allow_count=False,
allow_empty_first_page=True,
orphans=0,
):
self.queryset = queryset
self.per_page = int(per_page)
self.ordering = ordering
self.allow_count = allow_cou... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def can_paginate(operation_name=None):\n pass",
"def can_paginate(operation_name=None):\n pass",
"def can_paginate(operation_name=None):\n pass",
"def can_paginate(operation_name=None):\n pass",
"def can_paginate(operation_name=None):\n pass",
"def can_paginate(operation_name=None):\n p... | [
"0.5470511",
"0.5470511",
"0.5470511",
"0.5470511",
"0.5470511",
"0.5470511",
"0.5470511",
"0.5470511",
"0.5470511",
"0.5470511",
"0.5470511",
"0.5470511",
"0.5470511",
"0.5470511",
"0.5470511",
"0.5470511",
"0.5470511",
"0.54211426",
"0.52824336",
"0.52025956",
"0.52025956",... | 0.6878338 | 0 |
Counting the number of items is expensive, so by default it's not supported and None will be returned. | def count(self):
return self.queryset.count() if self.allow_count else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(self) -> Optional[int]:\n return pulumi.get(self, \"count\")",
"def count(self) -> Optional[int]:\n return pulumi.get(self, \"count\")",
"def count(item):\n return len(item)",
"def available(self):\n if self._count is not None:\n # If count is available, use it\n ... | [
"0.7429864",
"0.7429864",
"0.73906094",
"0.73351336",
"0.7263295",
"0.71967214",
"0.71967214",
"0.71967214",
"0.71967214",
"0.719134",
"0.71839863",
"0.71584815",
"0.7121969",
"0.7038985",
"0.6984783",
"0.6984783",
"0.6984783",
"0.6984783",
"0.6984783",
"0.6984783",
"0.698478... | 0.69155455 | 29 |
Attempt to fetch usage data from Xfinity. | def get_usage_data(username, password):
usage_req = XfinityUsage(username, password, browser_name="firefox-headless")
return usage_req.run() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getUsageInfo(self):\n return self.jsonRequest(\"/api/v1/usage\", { \"apiKey\": self._apiKey })",
"def _fetch_data(self):\n pass",
"def test_mock_datasource_usages(self):\n account1 = self.test_data.accounts[0]\n meter = account1.meters[0]\n usage = meter.usages[0]\n ... | [
"0.65825534",
"0.6223947",
"0.6160463",
"0.6084775",
"0.6011586",
"0.5991422",
"0.5960606",
"0.5794058",
"0.5778082",
"0.57704514",
"0.57532215",
"0.5739064",
"0.5734715",
"0.5715392",
"0.56156725",
"0.5563081",
"0.55498004",
"0.5534532",
"0.5509536",
"0.55004823",
"0.5500482... | 0.68384093 | 0 |
Parses usage data from `get_usage_data` into a simplified dictionary. | def parse_usage_data(usage_data):
try:
used = float(usage_data["used"])
total = float(usage_data["total"])
units = usage_data["units"]
except KeyError:
raise RuntimeError("Missing usage field")
except ValueError:
raise RuntimeError("Invalid float for usage")
try:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_usage_data(self):\n with self._lock:\n data_copy = self._data.copy()\n return data_copy",
"def getUsageInfo(self):\n return self.jsonRequest(\"/api/v1/usage\", { \"apiKey\": self._apiKey })",
"def _usage_report_dict(self, root):\n details = {}\n selector = ... | [
"0.595714",
"0.5901919",
"0.5696059",
"0.56513846",
"0.5559412",
"0.55006486",
"0.5456827",
"0.5399195",
"0.53736734",
"0.53501415",
"0.5313205",
"0.53006226",
"0.52940077",
"0.5287321",
"0.52843976",
"0.5270543",
"0.52501863",
"0.5234447",
"0.5186706",
"0.51861036",
"0.51832... | 0.7904441 | 0 |
Converts from bitwise representation into an array of vertex indices | def bits_to_verts(n):
return [v for v in range(8) if 2**v & n > 0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def toIndexes(self, binaryVector):\n\t\treturn n.array([i for i,v in enumerate(binaryVector) if v], dtype=\"int32\")",
"def indices(self):\n\n # We used lookup tables here. Read more about other methods here:\n # https://chessprogramming.wikispaces.com/Bitboard+Serialization\n\n if self.num ... | [
"0.6880614",
"0.66368663",
"0.6283147",
"0.61515015",
"0.59993356",
"0.5996714",
"0.5987039",
"0.597378",
"0.58865625",
"0.5886015",
"0.58810294",
"0.5878558",
"0.5835041",
"0.5816263",
"0.57732755",
"0.5763688",
"0.57467073",
"0.57454824",
"0.57390153",
"0.572041",
"0.569220... | 0.6249408 | 3 |
Converts from an array of vertex indices to a bitwise representation | def verts_to_bits(vs):
return sum(2**v for v in vs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vertex_group_ids_to_bitmask(vertex):\n list = [x.group for x in vertex.groups]\n masked = 0\n for group in list:\n masked |= 1 << group\n return masked",
"def flip_labels_with_indices(arr, indices):\n\n assert arr.ndim == 1, 'arr is not 1d!'\n assert np.all(np.unique(arr) == np.array... | [
"0.6393874",
"0.61002445",
"0.6074662",
"0.6046116",
"0.6043752",
"0.5958655",
"0.5898454",
"0.58136505",
"0.57977664",
"0.57674116",
"0.5753882",
"0.573017",
"0.57096016",
"0.56567574",
"0.5620509",
"0.5576903",
"0.5572747",
"0.5552426",
"0.5549938",
"0.5513818",
"0.54547226... | 0.69435185 | 0 |
Applies a vertex permutation operation to a set of vertices in bitwise representation | def bits_apply(op, n):
return verts_to_bits(op[v] for v in bits_to_verts(n)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_permutation(hyper, pol, perm):\n pass",
"def _permutation_to_vertex(self, p):\n return (\n tuple(p._labels[0]),tuple(p._labels[1]),\n tuple(p._twin[0]),tuple(p._twin[1]))",
"def _permutation_to_vertex(self, p):\n return (tuple(p._labels[0]),tuple(p._labels[1]),\n ... | [
"0.6501051",
"0.6195658",
"0.6121992",
"0.6116653",
"0.59749347",
"0.59226155",
"0.5864506",
"0.58285385",
"0.58096594",
"0.57623035",
"0.57196116",
"0.56820846",
"0.5677053",
"0.5631341",
"0.5579956",
"0.554991",
"0.5541649",
"0.5531225",
"0.5472351",
"0.54227304",
"0.541530... | 0.5487144 | 18 |
Applies a vertex permutation to a list of faces, optionally flipping the faces | def faces_apply(op, faces, flip):
return [face_apply(op, face, flip) for face in faces] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def face_apply(op, face, flip):\n edges = [edge_apply(op, edge) for edge in face]\n if flip: edges = list(reversed(edges))\n return edges",
"def permutations(cube):\r\n yield from rotations24(cube)\r\n yield from rotations24(np.flip(cube, 0))\r\n yield from rotations24(np.flip(cube, 1))\r\n ... | [
"0.6295819",
"0.57063204",
"0.56514055",
"0.5288726",
"0.5246789",
"0.5239562",
"0.51833093",
"0.517691",
"0.51233995",
"0.5112797",
"0.5077392",
"0.50435096",
"0.5018579",
"0.50046337",
"0.5001015",
"0.49998033",
"0.49979767",
"0.49799728",
"0.49551815",
"0.49465147",
"0.494... | 0.6877623 | 0 |
Applies a vertex permutation to a list of edges | def face_apply(op, face, flip):
edges = [edge_apply(op, edge) for edge in face]
if flip: edges = list(reversed(edges))
return edges | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_edges_perm(edges):\n L = dict(edges)\n output = [START_NODE]\n while output[-1] != END_NODE:\n output.append(L[output[-1]])\n if len(edges) + 1 != len(output):\n raise Exception()\n return output",
"def edgify(vertices:list)->list:\n edges = []\n for k in range(0, l... | [
"0.6615729",
"0.6356669",
"0.6107732",
"0.60739803",
"0.6059545",
"0.6019073",
"0.5929815",
"0.5906628",
"0.57717305",
"0.5688672",
"0.56653947",
"0.5655183",
"0.561524",
"0.5603018",
"0.55932075",
"0.55679923",
"0.55290484",
"0.5518229",
"0.54648507",
"0.5454239",
"0.5418100... | 0.53229946 | 30 |
Applies a vertex permutation to an edge. I.e. it permutes both ends of the edge, and finds the new edge that adjoins the two resulting vertex indices. | def edge_apply(op, edge):
vs = frozenset(op[v] for v in EDGES[edge])
return EDGES_BY_VERTSET[vs] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_permutation(V,m,adj):\r\n\r\n global tent\r\n\r\n perm = V.copy()\r\n \r\n \"\"\" try to select two vertices to swipe wisely. \"\"\"\r\n \r\n #we select 1 vertex among the m first vertices\r\n p1 = randint(0,m-1)\r\n \r\n #we select 1 vertex among the vertices left\r\n p2 = ra... | [
"0.61496586",
"0.60148495",
"0.5731535",
"0.5478552",
"0.54727155",
"0.5447548",
"0.5397627",
"0.53930193",
"0.53740484",
"0.53071874",
"0.53060764",
"0.53023404",
"0.52788925",
"0.52775645",
"0.525877",
"0.5247642",
"0.52019525",
"0.5191499",
"0.5182609",
"0.5179934",
"0.516... | 0.59890103 | 2 |
Applies a series of vertex permutations into a single new permutation | def compose(*ops):
if len(ops) == 0:
return [0, 1, 2, 3, 4, 5, 6, 7]
if len(ops) == 1:
return ops[0]
if len(ops) == 2:
op1, op2 = ops
return [op2[op1[v]] for v in range(8)]
op1 = ops[0]
rest = ops[1:]
return compose(op1, compose(*rest)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_permutation(hyper, pol, perm):\n pass",
"def new_permutation(V,m,adj):\r\n\r\n global tent\r\n\r\n perm = V.copy()\r\n \r\n \"\"\" try to select two vertices to swipe wisely. \"\"\"\r\n \r\n #we select 1 vertex among the m first vertices\r\n p1 = randint(0,m-1)\r\n \r\n #w... | [
"0.6906324",
"0.6441453",
"0.6377218",
"0.623576",
"0.6179371",
"0.61270565",
"0.60793066",
"0.6078905",
"0.60621685",
"0.60290956",
"0.5963186",
"0.59536695",
"0.5931516",
"0.59029084",
"0.57851154",
"0.57602996",
"0.5758229",
"0.5711937",
"0.57091004",
"0.56876945",
"0.5655... | 0.0 | -1 |
Repeats a vertex permutation n times | def pow(op, n):
return compose(* ([op] * n)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makePermutations(n):\n\thalf = n // 2\n\tfull = half * 2\n\tswap = np.random.rand(half) > 0.5\n\tpx = np.arange(n)\n\tpx[:full:2] += swap\n\tpx[1:full:2] -= swap\n\treturn px",
"def permutations(cube):\r\n yield from rotations24(cube)\r\n yield from rotations24(np.flip(cube, 0))\r\n yield from rotat... | [
"0.65971667",
"0.65550095",
"0.6534163",
"0.6501334",
"0.6494306",
"0.6486899",
"0.6421604",
"0.6302786",
"0.6279778",
"0.6265627",
"0.6223219",
"0.6217137",
"0.62151647",
"0.6209237",
"0.61867625",
"0.61583555",
"0.60585505",
"0.604222",
"0.6039225",
"0.60213876",
"0.5980881... | 0.0 | -1 |
Returns the midpoint of the edge, scaled by 2 | def d_midpoint(edge):
v0, v1 = EDGES[edge]
v0_pos = VERTICES[v0]
v1_pos = VERTICES[v1]
return ((x+y) for (x,y) in zip(v0_pos, v1_pos)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getMidPoint(self):\n return p.Point((self.start.normalVector + self.end.normalVector)/2.0)",
"def midpoint(self) -> Tuple[int, int]:\n minx, miny, maxx, maxy = self.substrates.bounds\n return ((minx + maxx) // 2, (miny + maxy) // 2)",
"def midpoints(self):\n return self.bins[:, ... | [
"0.71897864",
"0.71782583",
"0.69667315",
"0.68740594",
"0.6849831",
"0.6820582",
"0.68040663",
"0.6604313",
"0.655959",
"0.6443173",
"0.64284766",
"0.6420485",
"0.64110684",
"0.64069355",
"0.6338997",
"0.6332368",
"0.6320957",
"0.6279374",
"0.6177305",
"0.60413665",
"0.60012... | 0.72003573 | 0 |
Returns the square of the length of two positions | def length_sq(pos1, pos2):
return sum((x-y)**2 for (x,y) in zip(pos1, pos2)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def length(a, b):\n return sqrt((a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]))",
"def two_point_length(tuple1, tuple2):\n tot_sum = 0\n tot_sum += pow(tuple1[0]-tuple2[0], 2)\n tot_sum += pow(tuple1[1]-tuple2[1], 2)\n tot_sum += pow(tuple1[2]-tuple2[2], 2)\n final_len = pow(tot_... | [
"0.77668077",
"0.7397608",
"0.7298026",
"0.7286897",
"0.7151986",
"0.69440967",
"0.68845505",
"0.6838329",
"0.68282306",
"0.66732067",
"0.663228",
"0.6612591",
"0.6606926",
"0.65746224",
"0.65694505",
"0.6530553",
"0.65292597",
"0.64804214",
"0.6469597",
"0.64584744",
"0.6403... | 0.840613 | 0 |
Calls each dot's display method | def display(self):
for i in range(0, len(self.top_row)):
self.top_row[i].display()
for i in range(0, len(self.bottom_row)):
self.bottom_row[i].display()
for i in range(0, len(self.left_col)):
self.left_col[i].display()
for i in range(0, len(self.right_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display(self):\r\n\t\tfor each_item in self.items:\r\n\t\t\teach_item.display()",
"def display(self):\n for x, p in zip(self.xs, self.ps):\n print(x, p)",
"def dot():\n print_message(\".\")",
"def display(self):\n while (True):\n self.print()\n choice... | [
"0.67835927",
"0.66843057",
"0.666886",
"0.65113515",
"0.6475496",
"0.6450511",
"0.6438653",
"0.64117676",
"0.6406389",
"0.64011604",
"0.63695925",
"0.6368356",
"0.6323673",
"0.6308699",
"0.6306104",
"0.6278271",
"0.6268307",
"0.6267662",
"0.62406975",
"0.62362784",
"0.623549... | 0.6552318 | 3 |
Given the location of pacman, remove the dot which has been eaten | def eat(self, x, y):
for dot in self.top_row:
if (dot.x in range(x-self.EAT_DIST, x+self.EAT_DIST) and
dot.y in range(y-self.EAT_DIST, y+self.EAT_DIST)):
self.top_row.remove(dot)
for dot in self.left_col:
if (dot.x in range(x-self.EAT_DIST, x+s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_letter(letter, strng):",
"def rm_dot(item):\n if len(str(item).split('.')) > 2:\n return item.replace('.', '', 1)\n else:\n return item",
"def remove_accronymes(txt):\n return re.sub(r'(?<!\\w)([A-Z])\\.', r'\\1', txt)",
"def remove_at_symbols(text):\n return text.replace... | [
"0.5764863",
"0.56930834",
"0.5624305",
"0.561746",
"0.55540574",
"0.5498374",
"0.53847456",
"0.529521",
"0.5261624",
"0.5258695",
"0.52553254",
"0.52407074",
"0.5233354",
"0.52231973",
"0.52170676",
"0.5213291",
"0.5207047",
"0.5196517",
"0.5182967",
"0.5152582",
"0.51511467... | 0.49672496 | 40 |
Returns the number of remaing dots in the collection | def dots_left(self):
return (len(self.top_row) +
len(self.bottom_row) +
len(self.left_col) +
len(self.right_col)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_length(full):\n length = 0\n while length < len(full) and (is_int(full[length]) or full[length] == \".\"):\n length += 1\n return length",
"def sentence_count(self):\n count = 0\n for line in self.lines:\n if '.' in line:\n count += 1\n if co... | [
"0.64962554",
"0.64053047",
"0.6216463",
"0.6174851",
"0.6148714",
"0.61460245",
"0.6102202",
"0.6085623",
"0.60542667",
"0.60527104",
"0.60527104",
"0.60527104",
"0.6040605",
"0.6025968",
"0.60231924",
"0.60001814",
"0.5998494",
"0.59954226",
"0.5974416",
"0.5965547",
"0.593... | 0.5766017 | 57 |
Calculates standard deviation for the parameters | def deviation_from_actual_value(array):
if array.ndim == 3:
deviations = np.zeros((array.shape[1],array.shape[2]))
for pt in range(array.shape[1]):
for param in range(array.shape[2]):
dev = np.std(array[:,pt,param])
deviations[pt,param] = dev
retur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def standard_deviation( values, sample=False ):\n return ma.sqrt( variance( values, sample ) )",
"def _std(self, data):\n var = stats.var(data)\n if var>0.0:\n sd = math.sqrt(var)\n else:\n sd = 0.0\n return sd",
"def standard_deviation(data):\n\n return ... | [
"0.78026533",
"0.7647307",
"0.76123196",
"0.76123196",
"0.7597832",
"0.75591713",
"0.75591713",
"0.7547501",
"0.74657285",
"0.7434376",
"0.742554",
"0.7424684",
"0.74159634",
"0.74136686",
"0.7356248",
"0.73473656",
"0.73449373",
"0.7275893",
"0.7271954",
"0.7239",
"0.7225868... | 0.6829382 | 58 |
Generate value for temporary column. | def temp_(code):
# Does the partial match criteria include at least one OLC code?
if centroid or northwest or southeast:
# Is the specified UBID code valid?
if buildingid.v2.isValid(code):
# Separate the UBID code into three OLC codes.
openlocatio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _fake_column_value(self, column_name, raw_value):\n if raw_value not in self.random_column_mappings[column_name]:\n self.random_column_mappings[column_name][raw_value] = uuid.uuid4().hex\n return self.random_column_mappings[column_name][raw_value]",
"def _get_value(self, value_column... | [
"0.6443928",
"0.586687",
"0.55891824",
"0.556972",
"0.5548356",
"0.55463386",
"0.5470742",
"0.53880584",
"0.5322259",
"0.528715",
"0.52488106",
"0.5237839",
"0.5124428",
"0.511907",
"0.51168317",
"0.51155615",
"0.51041496",
"0.5101956",
"0.5081746",
"0.50771576",
"0.50757074"... | 0.0 | -1 |
Generate value for temporary column. | def temp_(code):
# Does the partial match criteria include at least one criterion?
if centroid or north or east or south or west:
match = buildingid.v3.RE_PATTERN_.match(code)
# Is the specified UBID code valid?
if match is None:
return None
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _fake_column_value(self, column_name, raw_value):\n if raw_value not in self.random_column_mappings[column_name]:\n self.random_column_mappings[column_name][raw_value] = uuid.uuid4().hex\n return self.random_column_mappings[column_name][raw_value]",
"def _get_value(self, value_column... | [
"0.6443928",
"0.586687",
"0.55891824",
"0.556972",
"0.5548356",
"0.55463386",
"0.5470742",
"0.53880584",
"0.5322259",
"0.528715",
"0.52488106",
"0.5237839",
"0.5124428",
"0.511907",
"0.51168317",
"0.51155615",
"0.51041496",
"0.5101956",
"0.5081746",
"0.50771576",
"0.50757074"... | 0.0 | -1 |
Clears the screen for a clean user experience | def clear():
os.system('cls' if os.name == 'nt' else 'clear') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear(self) -> None:\n self.screen.clear()",
"def clear_screen(self) -> None:\n assert self.screen is not None\n self.screen.clear()\n self.refresh_screen()",
"def clearScreen():\n pass",
"def clear_screen(self):\n os.system('cls' if os.name == 'nt' else 'clear')",
... | [
"0.90538967",
"0.8771846",
"0.8672335",
"0.86050916",
"0.86050916",
"0.8545433",
"0.8500673",
"0.8455498",
"0.8432114",
"0.83662564",
"0.8340428",
"0.8340428",
"0.8340428",
"0.8273955",
"0.82572716",
"0.8220763",
"0.8220763",
"0.81928957",
"0.81839484",
"0.8150272",
"0.811245... | 0.72859526 | 52 |
Checks that the user has entered a date in the specified format | def date_format(date):
formatted = True
task_date = date
while formatted:
try:
datetime.datetime.strptime(task_date, "%m/%d/%Y")
formatted = False
clear()
except ValueError:
clear()
task_date = input(
"Sorry. That i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _validate(self, date, format):\n try:\n datetime.datetime.strptime(date, format) # format = \"%m/%d/%Y\"\n return True\n except ValueError:\n return False",
"def _validate(self, date, format):\n try:\n datetime.datetime.strptime(date, format) #... | [
"0.8078952",
"0.8078952",
"0.79856914",
"0.7561423",
"0.75526595",
"0.7543216",
"0.7513091",
"0.7494118",
"0.7473142",
"0.7441406",
"0.7438409",
"0.74290854",
"0.7388282",
"0.73706716",
"0.7357162",
"0.73103935",
"0.72623146",
"0.7257095",
"0.71837956",
"0.71804875",
"0.71614... | 0.67866516 | 44 |
Verifies that the user has entered the time spent in a rounded minutes format | def time_format(time):
task_time = time
formatted = True
while formatted:
try:
int(task_time)
formatted = False
clear()
except ValueError:
clear()
task_time = input("Please submit the time in rounded minutes: \n>")
return task_t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def enter_time_spent():\n valid_data = False\n # used to keep track of the values and change them in other scopes\n input_data = {'time_spent': ''}\n\n while not valid_data:\n input_data['time_spent'] = input(\"Time spent on task (rounded minutes) : \")\n if re.match('\\d+', input_data['t... | [
"0.694629",
"0.6748994",
"0.638864",
"0.6357921",
"0.6322843",
"0.6196093",
"0.6184729",
"0.61560804",
"0.611747",
"0.6044115",
"0.6039488",
"0.6033791",
"0.60058755",
"0.6001399",
"0.6001399",
"0.5945724",
"0.59402835",
"0.5858136",
"0.58569",
"0.5838605",
"0.58353543",
"0... | 0.6721099 | 2 |
Searches the CSV for the user provided criteria, then calls the display_search_results function once it is found | def search_csv(search_criteria):
results_list = []
with open('work_log.csv', 'r') as file:
for row in file:
if search_criteria in row:
results_list.append(row)
results_sort(results_list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def proceed(results_sort):\n result_index = 0\n good = True\n with open('work_log.csv', 'r') as file:\n while good:\n proceed_prompt = input('Would you like to see the next '\n 'match (Y/N)? \\n>').upper()\n if proceed_prompt == 'Y':\n ... | [
"0.66718364",
"0.66616684",
"0.64814675",
"0.6412671",
"0.6390805",
"0.6351803",
"0.6337164",
"0.63014495",
"0.6237988",
"0.62156785",
"0.61356044",
"0.6060477",
"0.60499936",
"0.60499936",
"0.60210896",
"0.6012082",
"0.6007237",
"0.59896463",
"0.59748703",
"0.5954872",
"0.59... | 0.7490647 | 0 |
Searches the csv file for the time spent on the task | def search_time(time_spent):
results_list = []
with open('work_log.csv', 'r') as file:
for row in file:
if time_spent in row:
results_list.append(row)
time_sort(time_spent, results_list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self,time):\n \n fname = []\n tind =[]\n for t in time:\n flag=1\n for f in self.timelookup.keys():\n\n if t >= self.timelookup[f][0] and t<=self.timelookup[f][-1]:\n# print 'Found tstep %s'%datetime.strptime(t,'%Y-%m-... | [
"0.62988394",
"0.6165839",
"0.6142794",
"0.613546",
"0.61039007",
"0.6103374",
"0.59048325",
"0.5850628",
"0.58097833",
"0.5788802",
"0.57876265",
"0.57777923",
"0.5762286",
"0.5760471",
"0.57439256",
"0.57371503",
"0.5698138",
"0.5673036",
"0.5657542",
"0.56012",
"0.560112",... | 0.70304364 | 0 |
Uses a regex pattern to search the CSV for the users specified criteria | def reg_csv_search(arg):
results_list = []
with open('work_log.csv', 'r') as file:
for row in file:
if re.search(arg, str(row)):
results_list.append(row)
results_sort(results_list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search_csv(search_criteria):\n results_list = []\n with open('work_log.csv', 'r') as file:\n for row in file:\n if search_criteria in row:\n results_list.append(row)\n results_sort(results_list)",
"def match_name(pattern, rows):\n matching = []\n for row in... | [
"0.67888",
"0.6470334",
"0.6396413",
"0.6255691",
"0.5961034",
"0.5894265",
"0.5788759",
"0.57324696",
"0.56589437",
"0.5637524",
"0.56029505",
"0.5554282",
"0.55365884",
"0.55257493",
"0.5497352",
"0.54574275",
"0.5443628",
"0.5270864",
"0.52509785",
"0.5232844",
"0.522245",... | 0.73986834 | 0 |
Asks the user if they would like to proceed to the next search match or return to the main menu | def proceed(results_sort):
result_index = 0
good = True
with open('work_log.csv', 'r') as file:
while good:
proceed_prompt = input('Would you like to see the next '
'match (Y/N)? \n>').upper()
if proceed_prompt == 'Y':
result... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search_again(self):\n\n response = input(\n \"\\nWould you like to search for something else? (Yes or No): \")\n\n while response.lower().strip() != 'yes' or response.lower().strip() != 'no':\n\n if response.lower().strip() == 'yes':\n search_method_choice = s... | [
"0.72866863",
"0.67840254",
"0.67181313",
"0.67010593",
"0.6606882",
"0.6564676",
"0.65373194",
"0.6530345",
"0.6452046",
"0.6443651",
"0.64413977",
"0.6321795",
"0.6321795",
"0.62783706",
"0.62707144",
"0.6233784",
"0.6147132",
"0.6137649",
"0.6078425",
"0.60593116",
"0.6048... | 0.63667834 | 11 |
Asks the user if they would like to proceed to the next search match or return to the main menu | def proceed_time(time_spent, results_sort):
result_index = 0
good = True
with open('work_log.csv', 'r') as file:
while good:
proceed_prompt = input('Would you like to see the next '
'match (Y/N)? \n>').upper()
if proceed_prompt == 'Y':
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search_again(self):\n\n response = input(\n \"\\nWould you like to search for something else? (Yes or No): \")\n\n while response.lower().strip() != 'yes' or response.lower().strip() != 'no':\n\n if response.lower().strip() == 'yes':\n search_method_choice = s... | [
"0.72863895",
"0.6784519",
"0.6718815",
"0.67012006",
"0.6608094",
"0.65645003",
"0.6537902",
"0.65299827",
"0.64510673",
"0.6442261",
"0.64421093",
"0.6366394",
"0.6320764",
"0.6320764",
"0.6278601",
"0.6270224",
"0.62320995",
"0.6146126",
"0.6137398",
"0.60778147",
"0.60583... | 0.0 | -1 |
Displays the users desired criteria in a user friendly format | def display_search_results(results):
new_list = results.split(',')
print('Date : {}'.format(new_list[0]))
print('Title : {}'.format(new_list[1]))
print('Time Spent : {}'.format(new_list[2]))
print('Notes : {}'.format(new_list[3]))
clear() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def criteria_display(self, obj):\n return markdownify(obj.criteria)",
"def __ui_choose_search_criteria_for_persons(self):\n print(\"By which criteria do you want to search persons?\\n\"\n \" 1. By name\\n\"\n \" 2. By phone number\\n\")\n user_choice = input... | [
"0.729246",
"0.6475465",
"0.6302368",
"0.60785484",
"0.60026693",
"0.57753193",
"0.56812596",
"0.56490254",
"0.56184477",
"0.56179726",
"0.5589205",
"0.5563888",
"0.5551328",
"0.5518226",
"0.5494235",
"0.54688364",
"0.5435666",
"0.54348785",
"0.54307306",
"0.5420073",
"0.5411... | 0.0 | -1 |
Displays the time criteria in a user friendly format | def display_time(time_spent, results):
time_list = results.split(',')
if time_list[2] == time_spent:
print('Date : {}'.format(time_list[0]))
print('Title : {}'.format(time_list[1]))
print('Time Spent : {}'.format(time_list[2]))
print('Notes : {}'.format(time_list[3]))
c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_time(self):\n hour = str(datetime.datetime.now().strftime(\"%H\"))\n minute = str(datetime.datetime.now().strftime(\"%M\"))\n\n hour1 = int(hour[0])\n hour2 = int(hour[1])\n minute1 = int(minute[0])\n minute2 = int(minute[1])\n\n self.light_number(self.numb... | [
"0.662041",
"0.6618704",
"0.65189946",
"0.6502401",
"0.63292795",
"0.6303609",
"0.62661237",
"0.6211137",
"0.61990756",
"0.6094369",
"0.6071117",
"0.6003552",
"0.60004944",
"0.59723264",
"0.59697723",
"0.59694594",
"0.59597594",
"0.59349036",
"0.59229594",
"0.5916387",
"0.591... | 0.6771459 | 0 |
Watch the pins and reconstruct transactions. | async def _monitor_recv(self):
while True:
await RisingEdge(self.clock)
await ReadOnly()
if self.bus.valid.value:
self._recv(int(self.bus.data.value)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def activatePinReading(self):\n\n for pin in self.pinsToMeasure:\n arduino.samplePinDuringCapture(self.f, self.pinMap[pin], self.wallClock)",
"def rescanblockchain(self, *args, **kwargs):\n pass",
"def notify(self):\n for customer in self.customers:\n customer.update... | [
"0.551483",
"0.5239121",
"0.51758367",
"0.5165967",
"0.51407325",
"0.5108498",
"0.50625914",
"0.5031228",
"0.50113636",
"0.49593377",
"0.49497795",
"0.49426496",
"0.49096787",
"0.48999128",
"0.48825422",
"0.48567903",
"0.48450917",
"0.48180082",
"0.4799888",
"0.47884685",
"0.... | 0.0 | -1 |
Test n5/n = 5 | async def mean_basic_test(dut):
BUS_WIDTH = int(dut.BUS_WIDTH.value)
await value_test(dut, [5] * BUS_WIDTH) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def five():\r\n \r\n n = 20\r\n divisible = False\r\n \r\n while divisible == False:\r\n n += 20\r\n divisible = True\r\n for i in range(20, 0, -1):\r\n if n % i != 0:\r\n divisible = False\r\n break\r\n return n",
"def Z(n):\n co... | [
"0.68741405",
"0.68214047",
"0.6767779",
"0.6581722",
"0.65181637",
"0.64457196",
"0.63073707",
"0.63073707",
"0.6244081",
"0.6204426",
"0.6193691",
"0.6183099",
"0.61796105",
"0.61215574",
"0.60917366",
"0.6087825",
"0.60302454",
"0.60219646",
"0.6012",
"0.600985",
"0.600085... | 0.0 | -1 |
Test for overflow nmax_val/n = max_val | async def mean_overflow_test(dut):
BUS_WIDTH = int(dut.BUS_WIDTH.value)
DATA_WIDTH = int(dut.DATA_WIDTH.value)
await value_test(dut, [2**DATA_WIDTH - 1] * BUS_WIDTH) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_valid_range(val, max_val):\n if val < 0:\n val = 0\n elif val > max_val:\n val = max_val\n else:\n pass\n return val",
"def normexponent(val):\n n = np.log10(val)\n if n < 0:\n n = int(n) - 1\n else:\n n = int(n)\n r... | [
"0.63276565",
"0.6182196",
"0.6137918",
"0.6084422",
"0.6055982",
"0.6047039",
"0.6044521",
"0.5964492",
"0.59547186",
"0.5945219",
"0.59124607",
"0.5856389",
"0.5852122",
"0.5821489",
"0.5820828",
"0.5815797",
"0.580666",
"0.5793909",
"0.5789581",
"0.57884365",
"0.5772079",
... | 0.5406247 | 61 |
Test mean of random numbers multiple times | async def mean_randomised_test(dut):
# dut_in = StreamBusMonitor(dut, "i", dut.clk) # this doesn't work:
# VPI Error vpi_get_value():
# ERROR - Cannot get a value for an object of type vpiArrayVar.
dut_out = StreamBusMonitor(dut, "o", dut.clk)
exp_out = []
with warnings.catch_warnings():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checkMean(mean, iterations=10000):\n resultMean = mean\n for x in range(iterations):\n resultMean += nextTime(mean)\n resultMean /= iterations\n return resultMean\n # This one is kinda bullshit. Random seeding is seemingly different than what doctest author intended. Why check the floats ... | [
"0.72472805",
"0.6431477",
"0.6431477",
"0.6419152",
"0.63732487",
"0.6226704",
"0.6222548",
"0.6181071",
"0.61689115",
"0.6168421",
"0.6133957",
"0.6133957",
"0.6133957",
"0.6133957",
"0.61324465",
"0.61039424",
"0.60864156",
"0.6069528",
"0.6055752",
"0.6047192",
"0.6026047... | 0.0 | -1 |
Tries to perform an urlopen(url).read(), with workarounds for broken certificate stores. On many Python installations, urllib has problems using the system certificate stores; this seems to be particularly true on macOS, it is so in a twisted way on Win32 and can be a problem on some Linux distros (where in general the... | def workaround_url_read(url):
from urllib.request import urlopen
from urllib.error import URLError
try:
return urlopen(url).read()
except URLError as ex:
import ssl
if len(ex.args) and isinstance(ex.args[0], ssl.SSLError):
logger.warn("SSL error reading catalog file %... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getfilehttps(self, url):\n ctx = ssl.create_default_context()\n ctx.check_hostname = False\n ctx.verify_mode = ssl.CERT_NONE\n response = urllib.request.urlopen(url, context=ctx)\n result = response.read()\n return result",
"def _fetch(url, ssl_verify = True):\n r... | [
"0.76082635",
"0.71762764",
"0.662815",
"0.66156995",
"0.65748215",
"0.6362366",
"0.631332",
"0.6236358",
"0.62360704",
"0.62359977",
"0.62280315",
"0.60872215",
"0.60525805",
"0.60064995",
"0.59848493",
"0.5960688",
"0.5955748",
"0.59550893",
"0.59434485",
"0.5941267",
"0.59... | 0.7631621 | 0 |
Ensure we have an alias to import is_affirmative as _is_affirmative for backward compatibility with Agent 5.x | def test_alias():
assert getattr(config, "_is_affirmative", None) is not None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_affordable(self, tx_message: TransactionMessage) -> bool:\n is_affordable = True\n if self.context.ownership_state.is_initialized:\n is_affordable = self.context.ownership_state.is_affordable_transaction(\n tx_message\n )\n if self.context.ledger_st... | [
"0.58096945",
"0.56020963",
"0.5278895",
"0.5237023",
"0.52046263",
"0.5125001",
"0.5096052",
"0.50864345",
"0.50788856",
"0.49949625",
"0.49739137",
"0.49159327",
"0.48837402",
"0.48781067",
"0.48724884",
"0.48707488",
"0.48390678",
"0.4833998",
"0.47909078",
"0.478799",
"0.... | 0.64019364 | 0 |
simple markov chain model for qa field | def cloudModel(PsPs, PcPc):
PsPc = 1 - PsPs
PcPs = 1 - PcPc
"""
transition matrix -- don't really need...
"""
P = np.array([[PsPs, PsPc],
[PcPs, PcPc]])
"""
initial condintion
"""
sunny = True
t0 = np.random.choice([False, True])
"""
run realisation
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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 IdentityExtra... | [
"0.5637491",
"0.5590359",
"0.5580348",
"0.5483759",
"0.542955",
"0.5413857",
"0.54065937",
"0.5316787",
"0.5316414",
"0.5286672",
"0.52820724",
"0.52810353",
"0.5273364",
"0.5269522",
"0.5262664",
"0.52541405",
"0.5239877",
"0.523715",
"0.52256894",
"0.52171457",
"0.521534",
... | 0.0 | -1 |
simulate simple BRDF BRDF is not random so we enforce a certain structure onto the BRDF First the SZA is modelled as a simple sin across the year One approach is a climatology from the MODIS data? For this i think sin waves of diff freq will give some characteristic covering can vary max and min angles to sensors | def angular1(brdf_settings):
# const
scaleconst = 2*np.pi/366
locals().update(brdf_settings)
def scale(x, a=5, b=10, xmin=-1, xmax=1):
"""
rescale the sin
a new min
b = new max
xmin = min of x
xmax = max of x
"""
return (b - a)*(x - xmin)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sim_any_sinmode(gls_obj, in_freq, times):\n k = np.where(np.round(gls_obj.freq, 5) == in_freq)[0]\n if len(k) > 1:\n k = k[0]\n amp = np.sqrt(gls_obj._a[k]**2 + gls_obj._b[k]**2)\n ph = np.arctan2(gls_obj._a[k], gls_obj._b[k]) / (2. * np.pi)\n T0 = times.min() - ph / in_freq\n offset =... | [
"0.6582506",
"0.6425722",
"0.6123549",
"0.6094703",
"0.6085024",
"0.6063853",
"0.6045906",
"0.6019445",
"0.6018563",
"0.60164666",
"0.60149175",
"0.60096467",
"0.597433",
"0.5969006",
"0.59594935",
"0.5911588",
"0.58930105",
"0.58714265",
"0.58433384",
"0.58316123",
"0.582491... | 0.68870825 | 0 |
rescale the sin a new min b = new max xmin = min of x xmax = max of x | def scale(x, a=5, b=10, xmin=-1, xmax=1):
return (b - a)*(x - xmin)/(xmax - xmin) + a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rescale(self, xmin, xmax):\n\n # Normalise\n self.normalise()\n\n \n # Rescale\n range = xmax-xmin\n for seg in self.segments:\n seg.lower_bound = seg.lower_bound*range + xmin\n seg.upper_bound = seg.upper_bound*range + xmin",
"def sin_inplace(a... | [
"0.634048",
"0.6331223",
"0.605195",
"0.6003298",
"0.5982807",
"0.5972186",
"0.5926084",
"0.5825354",
"0.57681715",
"0.5748232",
"0.5718174",
"0.5701674",
"0.56905395",
"0.5674951",
"0.5660613",
"0.5647292",
"0.5632954",
"0.55880105",
"0.55765074",
"0.55494636",
"0.5454097",
... | 0.67776537 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.