Пример #1
0
void KstPSDCurve::setLen(int in_len) {
  if (in_len >= 4 && in_len <= 24) {
    Len = in_len;
  } else {
    Len = 10;
  }

  PSDLen = int(pow(2,Len-1));
  (*_sVector)->resize(PSDLen);

  ALen = PSDLen*2;
  delete[] a;
  a = new double[ALen];
  delete[] w;
  w = new double[ALen];
  GenW();

  last_f0 = 0;
  last_n_subsets = 0;

}
Пример #2
0
void KstPSDCurve::commonConstructor(const QString &in_tag, KstVectorPtr in_V,
                                    double in_freq, int in_len,
                                    const QString &in_VUnits,
                                    const QString &in_RUnits,
                                    const QColor &in_color) {

  _typeString = i18n("Power Spectrum");
  NumUsed = 0;
  _inputVectors[INVECTOR] = in_V;
  Color = in_color;
  setTagName(in_tag);
  Freq = in_freq;
  Len = in_len;
  VUnits = in_VUnits;
  RUnits = in_RUnits;

  PSDLen = int(pow(2, Len-1));

  ALen = PSDLen*2;
  a = new double[ALen];
  w = new double[ALen];
  GenW();

  last_f0 = 0;
  last_n_subsets = 0;
  last_n_new = 0;
  setRemoveMean(true);
  setAppodize(true);

  KstVectorPtr iv = new KstVector(in_tag+"-freq", 2);
  _fVector = _outputVectors.insert(FVECTOR, iv);

  iv = new KstVector(in_tag+"-sv", PSDLen);
  _sVector = _outputVectors.insert(SVECTOR, iv);

  update();
}
Пример #3
0
void KstPSDGenerator::updateNow() {

  int i_subset, i_samp;
  int n_subsets;
  int v_len;
  int copyLen;
  QValueVector<double> psd, f;
  double mean;
  double nf;
  bool done;
  
  adjustLengths();
  
  v_len = _inputVector->size();
  n_subsets = v_len/_PSDLen+1;
  if (v_len%_PSDLen==0) n_subsets--;

  // always update when asked
  _last_n_new = _inputVector->size();

  for (i_samp = 0; i_samp < _PSDLen; i_samp++) {
    (*_powerVector)[i_samp] = 0;
    (*_frequencyVector)[i_samp] = i_samp*0.5*_Freq/( _PSDLen-1 );
  }
  _frequencyVectorStep = 0.5*_Freq/(_PSDLen - 1);

  nf = 0;
  done = false;
  for (i_subset = 0; !done; i_subset++) {
    // copy each chunk into a[] and find mean
    if (i_subset*_PSDLen + _ALen < v_len) {
      copyLen = _ALen;
    } else {
      copyLen = v_len - i_subset*_PSDLen;
      done = true;
    }

    mean = 0;
    for (i_samp = 0; i_samp < copyLen; i_samp++) {
      mean += (
        _a[i_samp] =
        _inputVector->at(i_samp + i_subset*_PSDLen)
        );
    }
    if (copyLen > 1) {
      mean /= (double)copyLen;
    }

    if (apodize()) {
      GenW(copyLen);
    }
     
    // remove mean and apodize
    if (removeMean() && apodize()) {
      for (i_samp=0; i_samp<copyLen; i_samp++) {
        _a[i_samp]= (_a[i_samp]-mean)*_w[i_samp];
      }
    } else if (removeMean()) {
      for (i_samp=0; i_samp<copyLen; i_samp++) {
        _a[i_samp] -= mean;
      }
    } else if (apodize()) {
      for (i_samp=0; i_samp<copyLen; i_samp++) {
        _a[i_samp] *= _w[i_samp];
      }
    }
    nf += copyLen;


    for (;i_samp < _ALen; i_samp++) {
      _a[i_samp] = 0.0;
    }
    // fft a
    rdft(_ALen, 1, _a);
    (*_powerVector)[0] += _a[0]*_a[0];
    (*_powerVector)[_PSDLen-1] += _a[1]*_a[1];
    for (i_samp=1; i_samp<_PSDLen-1; i_samp++) {
      (*_powerVector)[i_samp]+= cabs2(_a[i_samp*2], _a[i_samp*2+1]);
    }
  }

  _last_f0 = 0;
  _last_n_subsets = n_subsets;
  _last_n_new = 0;
  nf = 1.0/(double(_Freq)*double(nf/2.0));
  for ( i_samp = 0; i_samp<_PSDLen; i_samp++ ) {
    (*_powerVector)[i_samp] = sqrt((*_powerVector)[i_samp]*nf);
  }
  if (_Freq <= 0.0) {
    _Freq = 1.0;
  }
}