bpmprocess/process_waveform.c

Go to the documentation of this file.

#include <stdio.h>
#include <bpm/bpm_units.h>
#include <bpm/bpm_messages.h>
#include <bpm/bpm_process.h>

int process_waveform( enum bpmtype_t type, bpmconf_t *bpm, bpmcalib_t *cal, bpmsignal_t *sig, 
                      bpmproc_t *proc, bpmproc_t *trig, unsigned int mode ) {


  int have_fft_pars = FALSE;
  int have_fit_pars = FALSE;
  double freq, tdecay, amp, phase;
  char msg[128];
  
  if ( ! bpm || ! sig || ! proc || ! trig ) {
    bpm_error( "Invalid pointer arguments in process_waveform(...)",
               __FILE__, __LINE__ );
    return BPM_FAILURE;
  }
  
  // reset the success values for this pulse...
  proc->fft_success = FALSE;
  proc->fit_success = FALSE;
  proc->ddc_success = FALSE;

  // check whether we have the correct mode
  if( bpm->cav_type != type ) {
    sprintf( msg, "Wrong cavity type for BPM %s in process_waveform(...)", bpm->name );
    bpm_error( msg, __FILE__, __LINE__ );
    return BPM_FAILURE;
  }

  // do we have a signal ?
  if ( ! sig->wf ) {
    sprintf( msg, "No signal present for BPM %s in process_waveform(...)", bpm->name );
    bpm_error( msg, __FILE__, __LINE__ );
    return BPM_FAILURE;
  }

  // determing voltage offset and amplitude noise in adc channels (pedestal)
  if ( get_pedestal( sig->wf, bpm->digi_nsamples, 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;
  }

  /* ------------------------------ check whether to do FFT ? -------------------------------- */
  if ( mode & PROC_DO_FFT ) {

    // compute the ft
    if ( fft_waveform( sig->wf, bpm->digi_nsamples, proc->fftwf ) == BPM_FAILURE ) {
      sprintf( msg, "Could not perform fft for BPM %s in process_waveform(...)", bpm->name );
      bpm_warning( msg, __FILE__, __LINE__ );

    } else {
      // fft done, fit for frequency and tdecay
      if( fit_fft( proc->fftwf, bpm->digi_nsamples, bpm->digi_freq, 
                   &(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__ );
      } else { 
        have_fft_pars = TRUE;
        proc->fft_success = TRUE;
      }

      
    }

  } /* if ( mode & PROC_DO_FFT ) */


  /* ------------------------------ check whether to do FIT ? -------------------------------- */
  if ( mode & PROC_DO_FIT ) {
    
    // initial parameters
    freq = tdecay = amp = phase = 0.;

    // what to use for initial parameters ?
    // is the fitted frequency from last pulse reasonable, as in > 0 and < nyquist freq
    // is amplitude and decay constant reasonable ?

    if ( proc->fit_freq <= 0.*MHz || proc->fit_freq > ( bpm->digi_freq/2.) ) {
      if ( ( bpm->rf_LOfreq > 0. ) && ( bpm->cav_freq > 0. ) ) {
        freq = ABS( bpm->cav_freq - bpm->rf_LOfreq );
      } else freq = 20.0*MHz;
    } else freq = proc->fit_freq; // use last fitted value

    if ( proc->fit_tdecay <= 10.*nsec || proc->fit_tdecay > 1.0*usec ) {
      if ( bpm->cav_decaytime > 0. ) tdecay = bpm->cav_decaytime;
      else tdecay = 0.2*usec;
    } else tdecay = proc->fit_tdecay; // use last fitted value

    // probably can think of something more clever here...
    if( ABS( proc->fit_amp ) < 100000. ) amp = proc->fit_amp; else amp = 3000.;
    phase  = proc->fit_phase;
    
    // if we have down the FFT and got the frequency from there, use that as an inital parameter
    // so overwrite the previous
    if( have_fft_pars ) {
      freq   = proc->fft_freq;
      tdecay = proc->fft_tdecay; 
    }

    // Slight hack to sort out saturation and trigger offsets
    // Change t0, fit, then extrapolate back
    int unsat_sample;
    if ( handle_saturation( sig->wf, bpm->digi_nsamples, 200, bpm->digi_nbits, 64, &unsat_sample ) == BPM_FAILURE ) {
      bpm_error( "Unable to handle saturation in process_waveform(...)",
                 __FILE__, __LINE__ );
      return BPM_FAILURE;
    }
    
    double t0;
    sample_to_time(bpm->digi_freq, bpm->digi_nsamples, unsat_sample, &t0 );
    t0 = ( t0 > ( trig->t0 + cal->t0Offset ) ? t0 : trig->t0 + cal->t0Offset);

    if ( fit_waveform( sig->wf, bpm->digi_nsamples, t0, bpm->digi_freq, 
                       freq, tdecay, amp, phase,
                       &(proc->fit_freq), &(proc->fit_tdecay), &(proc->fit_amp) ,
                       &(proc->fit_phase) ) == BPM_FAILURE ) {
        sprintf( msg, "Could not fit for BPM %s in process_waveform(...)", bpm->name );
        bpm_warning( msg, __FILE__, __LINE__ );
    } else { 
      have_fit_pars = TRUE;
      proc->fit_success = TRUE;

      // Extrapolate back
      proc->fit_amp *= exp( ( t0 - trig->t0 ) / proc->fit_tdecay );
      proc->fit_phase -= (t0 - trig->t0) * proc->fit_freq * 2. * PI;
    }

  } /* if ( mode & PROC_DO_FIT ) */


  /* ------------------------------ check whether to do DDC ? -------------------------------- */
  if ( mode & PROC_DO_DDC ) {
    
    // initial parameters
    freq = tdecay = 0.;

    // where does the ddc get its freq and tdecay parameters from ?
    if ( mode & PROC_DDC_FITFREQ ) {
      if ( have_fit_pars ) freq = proc->fit_freq;
      else freq = cal->freq; // asked for fit but it failed :(
    } else if ( mode & PROC_DDC_FFTFREQ ) {
      if ( have_fft_pars ) freq = proc->fft_freq;
      else freq = cal->freq; // asked for fft but it failed :(
    } else {
      // use default
      freq = cal->freq;
    }

    // same for tdecay
    if ( mode & PROC_DDC_FITTDECAY ) {
      if ( have_fit_pars ) tdecay = proc->fit_tdecay;
      else tdecay = cal->tdecay; // asked for fit but it failed :(
    } else if ( mode & PROC_DDC_FFTTDECAY ) {
      if ( have_fft_pars ) tdecay = proc->fft_tdecay;
      else tdecay = cal->tdecay; // asked for fft but it failed :(
    } else {
      // use default
      tdecay = cal->tdecay;
    }
    
    // do the downconversion...
    if ( ddc_sample_waveform( sig->wf, bpm->digi_nsamples, bpm->digi_nbits, bpm->digi_freq,
                              trig->t0, cal->t0Offset, freq, tdecay, 
                              cal->ddcfiltBW, cal->ddcepsFilt, 
                              &(proc->ddc_amp), &(proc->ddc_phase) ) == BPM_FAILURE ) {
      sprintf( msg, "Could not downconvert BPM %s waveform in process_waveform(...)", bpm->name );
      bpm_warning( msg, __FILE__, __LINE__ );
    } else {

      proc->ddc_success = TRUE;

      if ( mode & PROC_DDC_STOREFULL ) {
        // if the sampling ddc failed, no need in trying to get the whole waveform
        // otherwise, if requestes, let's do it here...
        ddc_waveform( sig->wf, bpm->digi_nsamples, bpm->digi_nbits, bpm->digi_freq,
                      trig->t0, freq, tdecay, cal->ddcfiltBW, cal->ddcepsFilt,
                      proc->ddcwf );
        

        // HERE if the user request to fit the DDC waveform we can update the
        // proc->ddc_tdecay from the fitted waveform
        // so need to implement something like
        
        // fit_ddc( proc->ddcwf, bpm->digi_nsamples, bpm->digi_freq, &(proc->ddc_tdecay) );

      }


    }

    
  } /* if ( mode & PROC_DO_DDC ) */

  return BPM_SUCCESS;
}

---