void MainContentComponent::calc_tuning() { //calculate tuning //initialise fft i/o-buffers: in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * file_len); out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * file_len); p = fftw_plan_dft_1d(file_len, in, out, FFTW_FORWARD, FFTW_ESTIMATE); for(long n=0; n<file_len; n++) { // fill fft input buffer: in[n][0] = file_buf[n]; // real part in[n][1] = 0; // imag part } fftw_execute(p); // execute fft file_mX = new float[file_len]; //get mag and phase: file_pX = new float[file_len]; for(long n=0; n<file_len/2; n++) { file_mX[n] = c_abs(out[n][0], out[n][1]); file_pX[n] = c_arg(out[n][0], out[n][1]); /* std::cout<<"magnitude: "<<file_mX[n]; std::cout<<"\tphase: "<<file_pX[n]<<std::endl; */ } fftw_destroy_plan(p); fftw_free(in); fftw_free(out); ladder = new tuning(file_mX, file_len/2, key_count, mirror_tuning, peak_tresh, file_fs); //(spectrum, length of spectrum (N/2 ivm symmetrie), // amount of keys, mirror intervals round 3/2?, // peak detection treshold) }
void output_root_pol(Complex * x, int odr, int form) { int i, k; double mag, arg, *a; a = dgetmem(2 * odr); switch (form) { case 1: for (k = i = 0; i < odr; i++) { a[k++] = c_mag(x[i + 1]); a[k++] = c_arg(x[i + 1]); } break; case 2: case 3: for (k = i = 0; i < odr; i++) { mag = 1 / c_mag(x[i + 1]); arg = -c_arg(x[i + 1]); if (form == 3) { a[k++] = mag; a[k++] = arg; } else { a[k++] = mag * cos(arg); a[k++] = mag * sin(arg); } } break; case 0: default: for (k = i = 0; i < odr; i++) { a[k++] = x[i + 1].re; a[k++] = x[i + 1].im; } break; } fwritef(a, sizeof(*a), odr * 2, stdout); return; }
subpaving::var process_add(app * t, unsigned depth, mpz & n, mpz & d) { unsigned num_args = t->get_num_args(); mpz_buffer ns(qm()), ds(qm()); var_buffer xs; scoped_mpq c(qm()), c_arg(qm()); scoped_mpz n_arg(qm()), d_arg(qm()); for (unsigned i = 0; i < num_args; i++) { expr * arg = t->get_arg(i); subpaving::var x_arg = process(arg, depth+1, n_arg, d_arg); if (x_arg == subpaving::null_var) { qm().set(c_arg, n_arg, d_arg); qm().add(c, c_arg, c); } else { xs.push_back(x_arg); ns.push_back(n_arg); ds.push_back(d_arg); } } qm().set(d, c.get().denominator()); unsigned sz = xs.size(); for (unsigned i = 0; i < sz; i++) { qm().lcm(d, ds[i], d); } scoped_mpz & k = d_arg; qm().div(d, c.get().denominator(), k); scoped_mpz sum_c(qm()); qm().mul(c.get().numerator(), k, sum_c); for (unsigned i = 0; i < sz; i++) { qm().div(d, ds[i], k); qm().mul(ns[i], k, ns[i]); } subpaving::var x; if (sz == 0) { qm().set(n, sum_c); x = subpaving::null_var; } else { x = s().mk_sum(sum_c, sz, ns.c_ptr(), xs.c_ptr()); qm().set(n, 1); } cache_result(t, x, n, d); return x; }
int process_caltone( doublewf_t *signal, bpmconf_t *bpm, bpmproc_t *proc, unsigned int mode ) { char msg[128]; if ( ! bpm || ! signal || ! proc ) { bpm_error( "Invalid pointer arguments in process_caltone(...)", __FILE__, __LINE__ ); return BPM_FAILURE; } // do we have a signal ? if ( ! signal ) { sprintf( msg, "No signal present for BPM %s in process_waveform(...)", bpm->name ); bpm_error( msg, __FILE__, __LINE__ ); return BPM_FAILURE; } /* ------------------------------- check for saturation ------------------------------------ */ proc->saturated = check_saturation( signal, bpm->digi_nbits, &(proc->iunsat) ); // report saturation in caltone... is not good :s if ( proc->saturated ) { bpm_warning( "Calibration tone is saturated, not updating caltone information...", __FILE__, __LINE__ ); } else { /* ------------------------------- subtract the pedestal ----------------------------------- */ // determing voltage offset and amplitude noise in adc channels (pedestal) if ( get_pedestal( signal, 20, &(proc->voltageoffset) ,&(proc->ampnoise) ) == BPM_FAILURE ) { sprintf( msg, "Error getting pedestal of BPM %s in process_waveform(...)", bpm->name ); bpm_error( msg, __FILE__, __LINE__ ); return BPM_FAILURE; } // subtract the pedestal doublewf_bias( -proc->voltageoffset, signal ); /* ------------------------------ check whether to do FFT ? -------------------------------- */ if ( mode & PROC_DO_FFT ) { // compute the ft if ( fft_waveform( signal, proc->ft ) == BPM_FAILURE ) { sprintf( msg, "Could not perform fft for BPM %s in process_caltone(...)", bpm->name ); bpm_warning( msg, __FILE__, __LINE__ ); } else { proc->fft_success = TRUE; if ( mode & PROC_FIT_FFT ) { // fft done, fit for frequency and tdecay if( fit_fft( proc->ft, &(proc->fft_freq), &(proc->fft_tdecay), NULL, NULL ) == BPM_FAILURE ) { sprintf( msg, "Could not fit the FFT for BPM %s in process_waveform(...)", bpm->name ); bpm_warning( msg, __FILE__, __LINE__ ); } } } } /* if ( mode & PROC_DO_FFT ) */ /* ------------------------------ check whether to do DDC ? -------------------------------- */ if ( mode & PROC_DO_DDC ) { // if we must to the full DDC, do it and sample afterwards if ( ddc_waveform( signal, bpm->ddc_ct_freq, bpm->ddc_ct_filter, proc->dc, bpm->ddc_buffer_re, bpm->ddc_buffer_im ) == BPM_FAILURE ) { sprintf( msg, "Could not ddc BPM %s waveform in process_caltone(...)", bpm->name ); bpm_warning( msg, __FILE__, __LINE__ ); } else { proc->ddc_success = TRUE; // Now sample the ddc waveform at the iSample requested, extrapolate amplitude proc->ddc_amp = c_abs( proc->dc->wf[ bpm->ddc_ct_iSample ] ); proc->ddc_phase = c_arg( proc->dc->wf[ bpm->ddc_ct_iSample ] ); norm_phase( &(proc->ddc_phase) ); // store phase and amplitude in the specially foreseen variables to store them // inbetween pulses... proc->ddc_ct_amp = proc->ddc_amp; proc->ddc_ct_phase = proc->ddc_phase; } } /* if ( mode & PROC_DO_DDC ) */ } // no saturation... return BPM_SUCCESS; }