bpmprocess/ddc_sample_waveform.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>

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

#ifndef DDC_SAMPLE_DEBUG__
#define DDC_SAMPLE_DEBUG__
#endif

#undef DDC_SAMPLE_DEBUG__


int ddc_sample_waveform( int *wf, int ns, int nbits, double fs, double t0, double t0Offset, 
                         double freq, double tdecay, double filtBW, double epsFilt,
                         double *amp, double *phase ) {

  int unsat_sample;
  double dt, tunsat, tstart, tfilter, tstop, omega;
  double **ddc, filt_ddc[2];
  char msg[80];
  int istart, ifilter, istop, i;

  if ( ! wf ) {
    bpm_error( "Invalid waveform pointer in ddc_sample_waveform(...)",
               __FILE__, __LINE__ );
    return BPM_FAILURE;
  }

  // get last unsaturated sample
  if ( handle_saturation( wf, ns, 200, nbits, 64, &unsat_sample ) == BPM_FAILURE ) {
    bpm_error( "Unable to handle saturation in ddc_sample_waveform(...)",
               __FILE__, __LINE__ );
    return BPM_FAILURE;
  }

#ifdef DDC_SAMPLE_DEBUG__
  printf( "DBG:[ddc_sample_waveform] last unsaturated sample : %d\n", unsat_sample );
  printf( "DBG:[ddc_sample_waveform] t0Offset : %f\n", t0Offset );
  fflush( stdout );
#endif

  // allocate complex ddc waveform
  ddc = alloc_complex_wave_double( ns );
  if ( ! ddc ) {
    bpm_error( "Unable to allocate memory for ddc in ddc_sample_waveform(...)",
               __FILE__, __LINE__ );
    return BPM_FAILURE;
  }

  // remove offset and downmix the waveform
  if ( downmix_waveform( wf, ns, fs, freq, t0, ddc ) == BPM_FAILURE ) {
    bpm_error( "Error in downmixing in ddc_sample_waveform(...)", 
               __FILE__, __LINE__ );
    return BPM_FAILURE;
  }

  // filter bandwidth given in MHz, convert it to rad/s
  omega = 2*PI*filtBW;
  
  // determine cut-off time from cut-off parameter epsFilt
  dt = sqrt( 2.*log( omega / ( sqrt(2.*PI) * epsFilt ) ) ) / omega;

  tstart  = t0Offset - dt;
  tfilter = t0Offset;
  tstop   = t0Offset + dt;

#ifdef DDC_SAMPLE_DEBUG__
  printf( "DBG:[ddc_sample_waveform] dt= %f, tstart= %f, tfilter= %f, tstop= %f\n", 
          dt/usec, tstart/usec, tfilter/usec, tstop/usec );
  fflush( stdout );
#endif

  // set tstart according to last unsaturated sample
  //sample_to_time( fs, ns, unsat_sample, &tunsat ); 
  //if ( tunsat <= tstart ) { 
  //  time_to_sample( fs, ns, tstart, &istart );
  //} else {
  //  istart = unsat_sample;
  //}

  time_to_sample( fs, ns, tstart, &istart );
  time_to_sample( fs, ns, tfilter, &ifilter );
  time_to_sample( fs, ns, tstop, &istop );
  
  if (istart < unsat_sample) {
    istop += (unsat_sample - istart);
    ifilter += (unsat_sample - istart);
    istart = unsat_sample;
  }

#ifdef DDC_SAMPLE_DEBUG__
  printf( "DBG:[ddc_sample_waveform] istart= %d, ifilter= %d, istop= %d\n", 
          istart, ifilter, istop );
  printf( "DBG:[ddc_sample_waveform] omega= %f, gamma= %f\n", freq, tdecay);
          
  fflush( stdout );
#endif


  // we need only the value at tfilter, so just perform one gaussian filter step
  if ( ddc_gaussfilter_step( ddc, ns, fs, istart, istop, tfilter, filtBW, filt_ddc ) 
       == BPM_FAILURE ) {
    bpm_error( "Error in performing gaussian filter step in ddc_sample_waveform(...)",
               __FILE__, __LINE__ );
    return BPM_FAILURE;
  }

  filt_ddc[Re] *= exp( ( tfilter - t0 ) / tdecay );
  filt_ddc[Im] *= exp( ( tfilter - t0 ) / tdecay );

  *amp   = sqrt( SQR( filt_ddc[Re] ) + SQR( filt_ddc[Im] ) );
  *phase = atan2( filt_ddc[Im], filt_ddc[Re] ); 

  /* free up */ 
  free_complex_wave_double( ddc, ns );

  return BPM_SUCCESS;
}

---