def kde(samples, filled=False): try: # samples = np.asarray(samples, dtype=np.float64).flatten() samples = samples.flatten() if ~np.isfinite(samples).all(): samples = get_finite_samples(samples) kde = gaussian_kde(samples) bw = kde.scotts_factor() * samples.std(ddof=1) #x = _kde_support(bw, bin_range=(samples.min(),samples.max()), clip=(samples.min(),samples.max())) x = kde_support(bw, bin_range=(samples.min(), samples.max())) y = kde(x) if filled: x = np.append(x, x[-1]) x = np.insert(x, 0, x[0], axis=0) y = np.append(y, 0.0) y = np.insert(y, 0, 0.0, axis=0) return dict(x=x, y=y) except ValueError: print( "KDE cannot be estimated because %s samples were provided to kde" % str(len(samples))) return dict(x=np.array([]), y=np.array([])) except LinAlgError as err: if 'singular matrix' in str(err): print("KDE: singular matrix") y = unit_impulse(100, 'mid') x = np.arange(-50, 50) if filled: x = np.append(x, x[-1]) x = np.insert(x, 0, x[0], axis=0) y = np.append(y, 0.0) y = np.insert(y, 0, 0.0, axis=0) return dict(x=x, y=y) else: raise
def setUp(self): #this will be run before the test functions # Create a telescope and observation self.dishes = np.array([[0, 0], [0, 55], [30, 30], [0, 60], [2, 55], [134, 65], [139, 163]]) self.acorner = np.array([[120, 270], [122, 280], [120, 280], [122, 270]]) self.HERA = HERA_hack.telescope(self.dishes, latitude=-30, channel_width=1., Tsys=300, beam_width=3, beam='gaussian') self.obs = HERA_hack.observation(self.HERA, 100., 100., 0.01, self.acorner, 1, 0.3, norm=True, pbeam=False) n_pix = self.obs.observable_coordinates().shape[0] imp = signal.unit_impulse(n_pix, 'mid') self.obs.convolve_map( imp ) # you have to run this in the setup so that all of the NONE variables get written! self.obs.generate_map_noise()
def playback(self, fs, duration, amplitude, frequency, phase, waveform, loop): # loop: boolean; waveform: SIN/SQR/RAMP/PULSE. self.fs = fs self.duration = duration self.amplitude = amplitude self.frequency = frequency self.phase = phase self.waveform = waveform self.loop = loop # Set the input numpy.array to reproduce. time = np.linspace(start=0, stop=duration, num=duration * fs) sound = None if waveform == 'SIN': sound = amplitude * np.sin(2 * np.pi * frequency * time + phase) elif waveform == 'SQR': sound = amplitude * sg.square(2 * np.pi * frequency * time + phase, 0.5) elif waveform == 'RAMP': sound = amplitude * sg.sawtooth( 2 * np.pi * frequency * time + phase, 0.5) elif waveform == 'PULSE': sound = amplitude * sg.unit_impulse(shape=np.size(time), idx='mid') sd.play(data=sound, samplerate=fs, blocking=False, loop=loop) return time, sound
def main(): """Meant to emulate how pyfda will pass parameters to filters""" # fs = 1000. # f1 = 45. # f2 = 95. # b = signal.firwin(3,[f1/fs*2,f2/fs*2]) #3 taps #b, a = signal.iirfilter(3, [0.4, 0.7], rs=60, btype='band', ftype='cheby2') # print(len(b)) # print(len(a)) # print(b) # print(a) #print(max([max(b),max(a)])) #convert floating point to fixed point sos = signal.ellip(3, 0.009, 80, 0.05, output='sos') x = signal.unit_impulse(10) y_sos = signal.sosfilt(sos, x) print(sos) #print(y_sos) B1 = 12 # Number of bits L1 = 2**(B1 - 1) # Round towards zero to avoid overflow sos_sc = sos * (2**(B1 - 1)) sos_sc_int = sos_sc.astype(int) print(sos_sc_int) y1 = fixp_sine(sos_sc_int, B1, L1) # #print(y1/2**B1) y2 = floatp_sine(sos, B1, L1)
def fixp_sine(bsc_int, asc_int, B1, L1): # N=20 # sig = [np.sin(0.1*np.pi*i) for i in np.arange(0,N,1)] sig = signal.unit_impulse(20) B2 = 12 # Number of bits L2 = math.floor(math.log((2 ** (B2 - 1) - 1) / max(sig), 2)) # Round towards zero to avoid overflow sig = np.multiply(sig, 2 ** L2) sig = sig.round() sig = sig.astype(int) print(sig) hdlfilter = FilterIIR() hdlfilter.set_coefficients(coeff_b=bsc_int, coeff_a=asc_int) hdlfilter.set_word_format((B1, B1 - 1, 0), (B2, B2 - 1, 0), (1000, 39, 0)) hdlfilter.set_stimulus(sig) hdlfilter.run_sim() y = hdlfilter.get_response() yout = np.divide(y, 2 ** B1) print(yout) # hdlfilter.convert(hdl = 'verilog') # TODO: plotting should not be included in the tests, # create simple scripts in filter-blocks/scripts # for plotting ... # plt.plot(yout, 'b') # plt.show() return yout
def playback_record(self, fs, duration, amplitude, frequency, phase, waveform, loop): self.fs = fs self.duration = duration self.amplitude = amplitude self.frequency = frequency self.phase = phase self.waveform = waveform self.loop = loop # Set the input numpy.array to reproduce time = np.linspace(start=0, stop=duration, num=duration * fs) sound = None if waveform == 'SIN': sound = amplitude * np.sin(2 * np.pi * frequency * time + phase) elif waveform == 'SQR': sound = amplitude * sg.square(2 * np.pi * frequency * time + phase, 0.5) elif waveform == 'RAMP': sound = amplitude * sg.sawtooth( 2 * np.pi * frequency * time + phase, 0.5) elif waveform == 'PULSE': sound = amplitude * sg.unit_impulse(shape=np.size(time), idx='mid') recording = sd.playrec( data=sound, samplerate=fs, blocking=False ) # If False, return immediately (but continue playrec in the background). return time, sound, recording
def make_some_noise(gaus=1., impuls=1., num_impuls=20, radio_impuls=1., num_radio=10, amp_freq=[(1., 10e-10)], amp=1): noize = np.zeros(32000) if amp == 0: return noize if gaus > 0: noize += np.random.normal(scale=gaus / 3, size=noize.shape) for amp_sinus, freq_sinus in amp_freq: if amp_sinus > 0: noize += np.fromfunction(lambda i: amp_sinus * np.sin((2 / 32000) * np.pi * freq_sinus * i), (32000,), dtype='float') if impuls > 0: freq = 32000 // num_impuls for i in range(num_impuls): j = random.randrange(i * freq, (i + 1) * freq) width = int(np.random.normal(loc=25, scale=10) % 20) try: noize[j:j + width] += np.random.normal(loc=impuls, scale=0.2 * impuls, size=width) except ValueError: pass if radio_impuls > 0 and num_radio > 0: freq = 32000 // num_radio b, a = signal.butter(4, 0.2) imp = signal.unit_impulse(25) for i in range(num_radio): j = random.randrange(i * freq, (i + 1) * freq) try: noize[j:j + 25] += 5 * radio_impuls * signal.lfilter(b, a, imp) except ValueError: pass noize *= amp return noize
def fixp_sine(sos_asc_int, B1, L1): sig = signal.unit_impulse(10) B2 = 12 # Number of bits L2 = math.floor(math.log((2**(B2 - 1) - 1) / max(sig), 2)) # Round towards zero to avoid overflow sig = np.multiply(sig, 2**L2) sig = sig.round() sig = sig.astype(int) print(sig) hdlfilter = FilterIIR() hdlfilter.set_coefficients(sos=sos_asc_int) hdlfilter.set_cascade(3) hdlfilter.set_word_format((B1, B1 - 1, 0), (B2, B2 - 1, 0), (1000, 39, 0)) hdlfilter.set_stimulus(sig) hdlfilter.run_sim() y = hdlfilter.get_response() #yout = np.divide(y, 2 ** B1) print(y) return y
def transform(self, input): """Generate a prediction basis set for the input as Toeplitz matrix. Parameters ---------- input : array or series Input data; should be one-dimensional Returns ------- output : 2D array or DataFrame Output data; has same type of input but will have multiple columns. """ row = signal.unit_impulse(self.n, 0) full_input = np.concatenate([input, np.zeros(self.offset)]) basis = linalg.toeplitz(full_input, row)[self.offset:] if isinstance(input, pd.Series): pad = int(np.floor(np.log10(self.n))) + 1 cols = [ f"{input.name}{self.suffix}{i:0{pad}d}" for i in range(self.n) ] basis = pd.DataFrame(basis, index=input.index, columns=cols) return basis
def generate_impulse(sample_length): print("Generating random impulse response...") rand_idx = randint(0, sample_length - 1) impulse = signal.unit_impulse(sample_length, rand_idx) return impulse
def transform(self, x): """Generate a prediction basis set for the input as Toeplitz matrix. Parameters ---------- input : array or series Input data; should be one-dimensional Returns ------- output : 2D array or DataFrame Output data; has same type of input but will have multiple columns. """ row = signal.unit_impulse(self.n, 0) x_full = np.concatenate([x, np.zeros(self.offset)]) basis = linalg.toeplitz(x_full, row)[self.offset:] if isinstance(x, pd.Series): pad = int(np.floor(np.log10(self.n))) + 1 cols = [ f"{x.name}{self.suffix}{i:0{pad}d}" for i in range(self.n) ] basis = pd.DataFrame(basis, index=x.index, columns=cols) return basis
def impulse_response(a0, a1, a2, b0, b1, b2, n=250): raise NotImplemented( 'biquad.impulse_response is not correctly implemented!') ir = signal.unit_impulse(n) for _a0, _a1, _a2, _b0, _b1, _b2 in zip(a0, a1, a2, b0, b1, b2): ir = signal.lfilter(np.concatenate([_b0, _b1, _b2]), np.concatenate([_a0, _a1, _a2]), ir) ir = np.concatenate(([0.0], ir)) return ir
def func(i): x = np.linspace(0, 2, 1000) g = 1 v0 = -30 y0 = 500 pos = int(0.5 * g * i**2 + v0 * i + y0) y = signal.unit_impulse(1000, pos) line.set_data(x, y) return line,
def __create_pulse(self, c, f): from scipy.signal import unit_impulse from model.signal import SingleChannelSignalData, Signal signal = Signal(f"pulse_{c}", unit_impulse(4 * HTP1_FS, 'mid'), self.__preferences, fs=HTP1_FS) return SingleChannelSignalData(name=f"pulse_{c}", filter=f, signal=signal)
def update(): y = 0 for i in range(0, len(band)): h = signal.unit_impulse(sig_len) z0 = signal.sosfilt(band[i].low, h) * band[i].gain z1 = signal.sosfilt(band[i].high, h) * band[i].gain y += z0 y += z1 return y
def unit_impulse(A, t1, d, fs, filename): ns = int(GUI.values['_ns_']) t2 = t1 + d N = int(d * fs) n = np.linspace(t1, t2, N) impuls = A * sig.unit_impulse(N, ns) x = calc.calc_signal(A, 0, t1, d, fs, 0, impuls) params = np.array([t1, fs, A, 0, d, 0]) np.savez(filename, params, impuls) return params, impuls
def full_sim(alpha_q=10, D_q=.1, gamma_q=20, alpha_a=100, D_a=1, gamma_a=20, q_thresh=80, a_thresh=700, D_rho=.05, dt=.05, K=10, rgrow=10, rkill=.5, rho_initial='none',nsteps=1): for n in range(nsteps): print(" ") print("Simulation running step %d out of %d"%(n+1,nsteps)) if(rho_initial=='none'): cell_initial_pos = tuple([tuple(np.random.randint(0,100,2)) for i in range(300)]) rho_initial = np.stack([signal.unit_impulse((100,100),i) for i in cell_initial_pos]) rho_initial = np.sum(rho_initial,axis=0) rho_fig = plt.figure() plt.imshow(rho_initial,cmap=plt.cm.gray,vmin=0,vmax=10) path = "C:\\Users\\dyanni3\\Desktop\\santola_sims\\RHO\\prhofig%d.png"%(n-1) rho_fig.savefig(path) qtot = np.zeros((100,100)) print("Configuring QS concentrations") for i in range(100): for j in range(100): progressBar((100*i)+j,10000) this_q = q(xx-x[j],yy-y[i],alpha_q,D_q,gamma_q) this_q[i,j]=q(.01,.01,alpha_q,D_q,gamma_q) qtot += rho_initial[i,j]*this_q qs_fig = plt.figure() plt.imshow(qtot) path = "C:\\Users\\dyanni3\\Desktop\\santola_sims\\QS\\pqsfig%d.png"%n qs_fig.savefig(path) atot = np.zeros((100,100)) rho_a = rho_initial*(qtot>q_thresh) print(" ") print("Configuring Antibiotic concentrations") for i in range(100): for j in range(100): progressBar((100*i)+j,10000) this_a = q(xx-x[j],yy-y[i],alpha_a,D_a,gamma_a) this_a[i,j] = q(.01,.01,alpha_a,D_a,gamma_a) atot += rho_a[i,j]*this_a a_fig = plt.figure() plt.imshow(atot,cmap=plt.cm.jet) path = "C:\\Users\\dyanni3\\Desktop\\santola_sims\\AB\\pabfig%d.png"%n a_fig.savefig(path) rho_safe = rho_initial*(atot>a_thresh) plt.imshow(rho_safe) rho_die = rho_initial*(atot<=a_thresh) D_kernel = np.array([[0,1,0],[1,-4,1],[0,1,0]]) rho_initial = rho_initial + dt*D_rho*signal.convolve2d(rho_initial,D_kernel,mode='same') rho_initial = rho_initial + dt*rho_safe*rgrow*(K-rho_initial)/K rho_initial = rho_initial - dt*rkill*rho_die rho_fig = plt.figure() plt.imshow(rho_initial,cmap=plt.cm.gray,vmin=0,vmax=10) path = "C:\\Users\\dyanni3\\Desktop\\santola_sims\\RHO\\prhofig%d.png"%n rho_fig.savefig(path) return(rho_initial)
def generate(self, amplitude: float, start_time: float, duration: float, sampling_frequency: float) -> Signal: x = self.get_arguments(start_time, duration, sampling_frequency) if start_time <= 0 and abs(round(start_time)) <= duration: index_of_jump = round(abs(start_time) / duration * (len(x) - 1)) y = amplitude * signal.unit_impulse(len(x), index_of_jump) else: y = x * 0.0 return Signal(start_time, 0.0, sampling_frequency, list(y), SignalType.REAL, SignalPeriodic.NO)
def accuracy(Y, t, size): error = np.zeros(10) for i in range(size): j = np.argmax(Y[:, i]) label = signal.unit_impulse(10, j) if np.dot(label, t[i, :]) != 1: j = np.argmax(t[i, :]) error[j] = error[j] + 1 accuracy = np.average(1 - error / size) return accuracy
def phiFence(): fence = np.zeros(xx.shape) for i in range(3): fence += 100. * (unit_impulse(xx.swapaxes(0, i).shape, (0,)) + unit_impulse(xx.swapaxes(0, i).shape, (-1,))).swapaxes(0, i) fence += 060. * (unit_impulse(xx.swapaxes(0, i).shape, (1,)) + unit_impulse(xx.swapaxes(0, i).shape, (-2,))).swapaxes(0, i) fence += 010. * (unit_impulse(xx.swapaxes(0, i).shape, (2,)) + unit_impulse(xx.swapaxes(0, i).shape, (-3,))).swapaxes(0, i) return fence
def generate_impulse(duration, baseline, sample_size, amplitude=127): impulse = sig.unit_impulse(duration + 1) multiple = math.ceil(float(sample_size) / float(duration)) i = np.array(list(impulse) * multiple) i = i[:sample_size] y = np.arange(len(i)) i = i * amplitude # plt.plot(y, i) # plt.xlabel('Time [Samples]') # plt.ylabel('Amplitude') # plt.show() return y, i
def f_of_q(q, model_number): ''' volume-limited binary mass ratio distribution. ''' if model_number in [1,5]: f_q = signal.unit_impulse(len(q), -1) elif model_number in [2,3,4,6,7]: f_q = q**β norm_q = trapz(f_q, q) f_q /= norm_q return f_q, norm_q
def flux_n_tr(k): """ Calculate the transmitted flux of resonant cyclotron scattering, see M.Lyutikov & F.P.Gavriil(2006) Input parameter: relation omega/omega_0 """ omega_0 = 8 omega = k * omega_0 # another way to find omega_0 independly #omega = 0.1 #omega_0 = omega/k dif = omega - omega_0 if k == 1: n_transm = ( exp(-tau_0 / 2) * (10 * signal.unit_impulse(2)[0] + tau_0 / (8 * beta_T * omega_0) * sqrt( (omega_0 * (1 + 4 * beta_T) - omega) / (dif + 0.1)) * special.i1( (tau_0 / (4 * beta_T * omega_0) * sqrt(dif * (omega_0 * (1 + 4 * beta_T) - omega)))))) elif 1 < k <= 1.4: n_transm = ( exp(-tau_0 / 2) * (signal.unit_impulse(2)[1] + tau_0 / (8 * beta_T * omega_0) * sqrt( (omega_0 * (1 + 4 * beta_T) - omega) / dif) * special.i1( (tau_0 / (4 * beta_T * omega_0) * sqrt(dif * (omega_0 * (1 + 4 * beta_T) - omega)))))) else: n_transm = 0 return n_transm
def main(): times = np.linspace(0, 256e-9, 256) b, a = signal.butter(9, 0.6) noise_1 = np.random.normal(0, 11 * 1e-6, 256) noise_2 = np.random.normal(0, 11 * 1e-6, 256) imp_1 = signal.unit_impulse(256, 100) imp_2 = signal.unit_impulse(256, 150) response_1 = signal.lfilter(b, a, imp_1) response_2 = signal.lfilter(b, a, imp_2) noisy_signal_1 = (response_1 * 4 * 1e-6) + noise_1 noisy_signal_2 = (response_2 * 4 * 1e-6) + noise_2 fig = plt.figure(figsize=(11, 8.5)) #make a figure object ax = fig.add_subplot(2, 1, 1) #make a subplot for the limit ax.plot(times, noisy_signal_1) ax = fig.add_subplot(2, 1, 2) #make a subplot for the limit ax.plot(times, noisy_signal_2) fig.savefig("test.png", edgecolor='none', bbox_inches="tight") #save the figure
def computeGradient(x,currentCost,twistMode): newCosts = np.zeros(7) if twistMode == 'flat': coordinates = 4 delta = np.array([0,0,0,0,1,1,1]) twistCost,_,_ = cost(x+np.multiply(epsilon,delta)) newCosts[4]=newCosts[5]=newCosts[6]=twistCost for i in range(coordinates): newCosts[i],_,_ = cost(x+np.multiply(epsilon,signal.unit_impulse(7,i))) gradient = np.divide(newCosts-currentCost,epsilon) return gradient
def psf_pc(self,radius,F,W,R): Lambda = 0.5 xx,yy = np.meshgrid(np.linspace(-radius,radius,2*radius+1), np.linspace(-radius,radius,2*radius+1)) scale2 = 10 xx = xx/scale2 yy = yy/scale2 rr = np.sqrt(xx**2 + yy**2) x = rr*(2*np.pi)*(1/F)*(1/Lambda) #ker = o_airy(rr_dl,R,W) ker = R*jv(1,2*3.1416*R*x)/x - (R-W)*jv(1,2*3.1416*(R-W)*x)/x ker[radius,radius] = np.nanmax(ker) ker = ker/np.linalg.norm(ker) ker -= unit_impulse(xx.shape,(radius,radius)) ker = gaussian(ker,1) #ker = self.normalize2max(ker) ker = ker/np.sum(ker) return ker
def floatp_sine(b, a, B1, L1): # sig = [np.sin(0.1*np.pi*i) for i in np.arange(0,x,1)] sig = signal.unit_impulse(10) # print(sig) B2 = 12 # Number of bits L2 = math.floor(math.log((2 ** (B2 - 1) - 1) / max(sig), 2)) # Round towards zero to avoid overflow # print(L) sig = np.multiply(sig, 2 ** L2) sig = sig.round() sig = sig.astype(int) y_tf = signal.lfilter(b, a, sig) print(y_tf) return y_tf
def test_freq_resp(self): # Test that frequency response meets tolerance from ITU-R BS.468-4 N = 12000 fs = 300000 impulse = signal.unit_impulse(N) out = ITU_R_468_weight(impulse, fs) freq = np.fft.rfftfreq(N, 1/fs) levels = 20 * np.log10(abs(np.fft.rfft(out))) if mpl: plt.figure('468') plt.semilogx(freq, levels, alpha=0.7, label='fft') plt.legend() plt.axis([20, 45000, -50, +15]) # Interpolate FFT points to measure response at spec's frequencies func = interp1d(freq, levels) levels = func(frequencies) assert all(np.less_equal(levels, responses + upper_limits)) assert all(np.greater_equal(levels, responses + lower_limits))
def test_freq_resp(self): # Test that frequency response meets tolerance from ANSI S1.4-1983 N = 40000 fs = 300000 impulse = signal.unit_impulse(N) out = A_weight(impulse, fs) freq = np.fft.rfftfreq(N, 1 / fs) levels = 20 * np.log10(abs(np.fft.rfft(out))) if mpl: plt.figure('A') plt.semilogx(freq, levels, alpha=0.7, label='fft') plt.legend() plt.ylim(-80, +5) # Interpolate FFT points to measure response at spec's frequencies func = interp1d(freq, levels) levels = func(frequencies) assert all(np.less_equal(levels, responses['A'] + upper_limits)) assert all(np.greater_equal(levels, responses['A'] + lower_limits))
def test_freq_resp(self): # Test that frequency response meets tolerance from ITU-R BS.468-4 N = 12000 fs = 300000 impulse = signal.unit_impulse(N) out = ITU_R_468_weight(impulse, fs) freq = np.fft.rfftfreq(N, 1 / fs) levels = 20 * np.log10(abs(np.fft.rfft(out))) if mpl: plt.figure('468') plt.semilogx(freq, levels, alpha=0.7, label='fft') plt.legend() plt.axis([20, 45000, -50, +15]) # Interpolate FFT points to measure response at spec's frequencies func = interp1d(freq, levels) levels = func(frequencies) assert all(np.less_equal(levels, responses + upper_limits)) assert all(np.greater_equal(levels, responses + lower_limits))
def gaussian_smoothing_test(plot_flag=PLOT_FLAG): kernel = signal.gaussian(50000, 10000) # Dirac delta function, 500 pts, @ center of these points dirac = signal.unit_impulse(50000, 'mid') convolved = signal.fftconvolve(dirac, kernel, 'same') #convolved = fftshift(convolved) xs = np.linspace(0., 1000, 50000) if plot_flag: fig, ax = plt.subplots(sharex=True) ax.plot(xs[1:], convolved[1:], 'r-', label='Convolution') ax.plot(xs[1:], kernel[1:], 'b--', label='Original Gaussian') ax.plot(xs[1:], dirac[1:], 'g', label='Dirac Delta') leg = ax.legend() fig.suptitle("Gaussian Smoothing Test") ax.set(xlabel='unit...time? idk, you choose', ylabel='the dependent variable') ax.label_outer plt.show() return convolved
def metronome(bpm, fs,timsig,bar,s=[]): while True: if (60*fs%bpm != 0): fs+=1 else: break samplehop= int((60/bpm)*fs) x = np.zeros(int(fs*((60/bpm)*bar*timsig))) barc=0 countsig=timsig si=0 for counter in range(len(x)): if (counter%samplehop==0): imp = signal.unit_impulse((int(fs*((60/bpm)*bar*timsig))), [counter]) if (s[si]==1): if(countsig==timsig): x = x+imp else: x = x+ (0.316*imp) elif (s[si]==0): x = x counter+=1 countsig-=1 si+=1 if(countsig==0): countsig = timsig barc+=1 si=0 if(barc==bar): break onset_gen = np.where(x>0) return x, onset_gen[0],fs
# Read the info from the sample dataset. This defines the location of the # sensors and such. info = mne.io.read_info(raw_fname) info.update(sfreq=sfreq, bads=[]) # Only use gradiometers picks = mne.pick_types(info, meg='grad', stim=True, exclude=()) mne.pick_info(info, picks, copy=False) # Define a covariance matrix for the simulated noise. In this tutorial, we use # a simple diagonal matrix. cov = mne.cov.make_ad_hoc_cov(info) cov['data'] *= (20. / snr) ** 2 # Scale the noise to achieve the desired SNR # Simulate the raw data, with a lowpass filter on the noise stcs = [(stc_signal, unit_impulse(n_samp, dtype=int) * 1), (stc_noise, unit_impulse(n_samp, dtype=int) * 2)] # stacked in time duration = (len(stc_signal.times) * 2) / sfreq raw = simulate_raw(info, stcs, forward=fwd) add_noise(raw, cov, iir_filter=[4, -4, 0.8], random_state=rand) ############################################################################### # We create an :class:`mne.Epochs` object containing two trials: one with # both noise and signal and one with just noise events = mne.find_events(raw, initial_event=True) tmax = (len(stc_signal.times) - 1) / sfreq epochs = mne.Epochs(raw, events, event_id=dict(signal=1, noise=2), tmin=0, tmax=tmax, baseline=None, preload=True) assert len(epochs) == 2 # ensure that we got the two expected events
"""Create some examples of time-domain NFC-HOA.""" import numpy as np import matplotlib.pyplot as plt import sfs from scipy.signal import unit_impulse # Parameters fs = 44100 # sampling frequency grid = sfs.util.xyz_grid([-2, 2], [-2, 2], 0, spacing=0.005) N = 60 # number of secondary sources R = 1.5 # radius of circular array array = sfs.array.circular(N, R) # Excitation signal signal = unit_impulse(512), fs, 0 # Plane wave max_order = None npw = [0, -1, 0] # propagating direction t = 0 # observation time delay, weight, sos, phaseshift, selection, secondary_source = \ sfs.td.nfchoa.plane_25d(array.x, R, npw, fs, max_order) d = sfs.td.nfchoa.driving_signals_25d( delay, weight, sos, phaseshift, signal) p = sfs.td.synthesize(d, selection, array, secondary_source, observation_time=t, grid=grid) plt.figure() sfs.plot2d.level(p, grid) sfs.plot2d.loudspeakers(array.x, array.n)