Brief description of class still missing. More...

#include <StationResults.h>

Public Types
enum	PeakValue { PeakFrequency, PeakAmplitude }
Signals
void	colorsToChange (const QVector< int > *selCurves, const QColor &col)
void	peakChanged ()
void	showColors (bool)
Public Member Functions
void	addPeak (double minFreq, double maxFreq)
void	addWindows (int winCount)
const Curve< Point2D > &	averageCurve () const
LineLayer *	averageLayer () const
const QString &	category () const
void	clear ()
void	clearPeaks ()
const Point &	coordinates () const
void	derivate ()
AxisWindow *	graph () const
double	highestPeak (PeakValue pv) const
void	integrate ()
TextEdit *	label () const
void	load (QString fileName)
double	lowestPeak (PeakValue pv) const
double	maximumAmplitude () const
double	maximumAmplitudePeak (PeakValue pv) const
const Curve< Point2D > &	maximumCurve () const
const Curve< Point2D > &	minimumCurve () const
AbstractStation *	parent () const
double	peak (int ib, PeakValue pv) const
int	peakCount () const
ParallelBands *	peakLayer () const
double	peakMaximum (int ib) const
double	peakMinimum (int ib) const
void	printAverage () const
void	printPeaks () const
void	printWindows () const
void	removePeak (int index)
void	save (QString fileName, QString log)
void	setAverageLayer ()
void	setCategory (const QString &c)
void	setCoordinates (const Point &p)
void	setGraph (AxisWindow *w)
void	setLabel (TextEdit *l)
void	setParent (AbstractStation *p)
void	setPeak (int index, double minFreq, double maxFreq)
void	setPeakLayer ()
void	setStationName (const QString &n)
void	setT10Layer (double averageWindowLength)
void	setVisibleLayers (int visibleLayers)
void	setWindow (int winIndex, DoubleSignal *sig)
void	setWindowColor (int winIndex, const QColor &col)
void	setWindowColor (const QVector< int > *selCurves, const QColor &col)
void	setWindows (int winCount, SamplingParameters &samp)
const QString &	stationName () const
	StationResults ()
LineLayer *	stddevLayer () const
ParallelBands *	t10Layer () const
int	windowCount () const
int	windowPeakCount (int ib) const
XUniqueYColorLines *	windowsLayer () const
Protected Member Functions
virtual QString	comments () const

Detailed Description

Brief description of class still missing.

Full description of class still missing

Member Enumeration Documentation

enum MonoStation::StationResults::PeakValue

Enumerator:

PeakFrequency
PeakAmplitude

{PeakFrequency, PeakAmplitude};

Constructor & Destructor Documentation

MonoStation::StationResults::StationResults ( )

Description of constructor still missing

References QGpCoreTools::tr(), and TRACE.

{
  TRACE;
  _t10Layer=0;
  _peakLayer=0;
  _windowsLayer=0;
  _averageLayer=0;
  _stddevLayer=0;
  _label=0;
  _category=tr("Default");
  _winCount=0;
  _nSamples=0;
  _nSamples2=0;
}

Member Function Documentation

void MonoStation::StationResults::addPeak	(	double	minFreq,
		double	maxFreq
	)

Adds a peak between minFreq and maxFreq.

References SciFigs::ParallelBands::addBand(), peakChanged(), setPeak(), TRACE, and SciFigs::XUniqueYColorLines::x().

Referenced by MonoStation::AbstractTool::outputResults(), and setPeakLayer().

{
  TRACE;
  if(_winCount<2) return;
  if(minFreq>0.0 && maxFreq>0.0) {
    if(minFreq>maxFreq) {
      double tmp=minFreq;
      minFreq=maxFreq;
      maxFreq=tmp;
    }
    const double * x=_windowsLayer->x();
    int iminFreq=frequency2Index(x, minFreq);
    int imaxFreq=frequency2Index(x, maxFreq);
    _nWindowsForPeaks.append(0);
    _peakLayer->addBand(QColor(Qt::lightGray));
    _peakLayer->addBand(QColor(Qt::gray));
    setPeak(_nWindowsForPeaks.count()-1, iminFreq, imaxFreq);

  }
  setToolTips();
  emit peakChanged();
}

void MonoStation::StationResults::addWindows ( int winCount )

References SciFigs::XUniqueYColorLines::colors(), SciFigs::XUniqueYColorLines::setColors(), SciFigs::XUniqueYColorLines::setPointCount(), and TRACE.

{
  TRACE;
  int new_winCount=_winCount + winCount;

  QColor * new_colors=new QColor[ new_winCount ];
  memcpy(new_colors, _windowsLayer->colors(), _winCount * sizeof(QColor));
  _windowsLayer->setColors(new_colors);
  _windowsLayer->setPointCount(new_winCount, _nSamples);

  _winCount=new_winCount;
}

const Curve< Point2D > & MonoStation::StationResults::averageCurve ( ) const

References SciFigs::LineLayer::line(), and TRACE.

Referenced by comments(), highestPeak(), lowestPeak(), maximumAmplitudePeak(), peak(), printAverage(), printPeaks(), setAverageLayer(), MonoStation::AbstractSummary::setAverageValues(), setPeakLayer(), MonoStation::AbstractSummary::setSpectrumGridValues(), MonoStation::AbstractSummary::setStackedValues(), MonoStation::StatisticResults::studentTest(), and MonoStation::WinResults::studentTest().

{
  TRACE;
  return static_cast<const PlotLine2D *>(_averageLayer->line(0))->curve();
}

LineLayer* MonoStation::StationResults::averageLayer ( ) const [inline]

Referenced by MonoStation::WinResultsOptions::setVisibleLayers(), and MonoStation::WinResultsOptions::visibleLayers().

{return _averageLayer;}

const QString& MonoStation::StationResults::category ( ) const [inline]

Referenced by MonoStation::WinResults::categoriesToGroups(), MonoStation::AbstractSummary::setBubbleValues(), and MonoStation::WinResults::setCategories().

{return _category;}

void MonoStation::StationResults::clear ( )

References SciFigs::ParallelBands::clear(), SciFigs::AbstractLine::clear(), SciFigs::XUniqueYColorLines::clear(), SciFigs::GraphContentLayer::graph(), SciFigs::LineLayer::line(), TRACE, and SciFigs::AxisWindow::update().

{
  TRACE;
  _winCount=0;
  _nWindowsForPeaks.clear();
  _nSamples=0;
  _nSamples2=0;
  _t10Layer->clear();
  _peakLayer->clear();
  _windowsLayer->clear();
  _averageLayer->line(0)->clear();
  _stddevLayer->line(0)->clear();
  _stddevLayer->line(1)->clear();
  _t10Layer->graph()->update();
}

void MonoStation::StationResults::clearPeaks ( )

Clears the list of peaks.

References SciFigs::ParallelBands::clear(), peakChanged(), and TRACE.

Referenced by MonoStation::AbstractTool::outputResults(), and setPeakLayer().

{
  TRACE;
  _nWindowsForPeaks.clear();
  _peakLayer->clear();
  setToolTips();
  emit peakChanged();
}

void MonoStation::StationResults::colorsToChange	(	const QVector< int > *	selCurves,
		const QColor &	col
	)		`[signal]`

QString MonoStation::StationResults::comments ( ) const [protected, virtual]

References QGpCoreTools::Curve< pointType >::at(), averageCurve(), SciFigs::ParallelBands::band(), SciFigs::ParallelBands::count(), SciFigs::ParallelBand::maximum(), maximumCurve(), SciFigs::ParallelBand::minimum(), minimumCurve(), str, QGpCoreTools::tr(), and TRACE.

{
  TRACE;
  int nb=_peakLayer->count()/2;
  QString str=_stationName;
  if(nb==0) {
    str+=tr("\nNo peak");
  } else {
    for(int ib=0; ib<nb; ib++) {
      const ParallelBand& b=_peakLayer->band(2*ib);
      str+=QString("\nf%1=%2+/-%3").arg(ib).arg(b.maximum()).arg(b.maximum()-b.minimum());
      str+=QString("\nA%1=%2 [%3,%4]")
           .arg(ib)
           .arg(averageCurve().at(b.maximum()).y())
           .arg(minimumCurve().at(b.maximum()).y())
           .arg(maximumCurve().at(b.maximum()).y());
    }
  }
  str+=tr("\nCategory: %1").arg(_category);
  return str;
}

const Point& MonoStation::StationResults::coordinates ( ) const [inline]

Referenced by MonoStation::AbstractSummary::setBubbleValues().

{return _coordinates;}

void MonoStation::StationResults::derivate ( )

References SciFigs::XUniqueYColorLines::mulYbyX(), SciFigs::LineLayer::mulYbyX(), and TRACE.

{
  TRACE;
  _windowsLayer->mulYbyX(2 * M_PI);
  _averageLayer->mulYbyX(2 * M_PI);
  _stddevLayer->mulYbyX(2 * M_PI);
}

AxisWindow* MonoStation::StationResults::graph ( ) const [inline]

Referenced by MonoStation::WinResults::options(), MonoStation::PeakItemModel::reset(), MonoStation::WinResults::saveResults(), MonoStation::WinResults::selectAll(), MonoStation::WinResults::setLimits(), MonoStation::WinResults::setPeaks(), StructureWinResults::setRatioLimits(), and StructureWinResults::setSpectrumLimits().

{return _averageLayer->graph();}

double MonoStation::StationResults::highestPeak ( PeakValue pv ) const

References QGpCoreTools::Curve< pointType >::at(), averageCurve(), SciFigs::ParallelBands::band(), SciFigs::ParallelBands::count(), SciFigs::ParallelBand::maximum(), PeakAmplitude, PeakFrequency, TRACE, and QGpCoreTools::Point2D::y().

Referenced by MonoStation::StationLine::setValue().

{
  TRACE;
  int nb=_peakLayer->count()/2;
  ASSERT(nb>0);
  double maxF=-1e99;
  for(int ib=0; ib<nb; ib++) {
    const ParallelBand& b=_peakLayer->band(2 * ib);
    if(b.maximum()>maxF) {
      maxF=b.maximum();
    }
  }
  switch(pv) {
  case PeakFrequency:
    return maxF;
  case PeakAmplitude:
    return averageCurve().at(maxF).y();
  }
}

void MonoStation::StationResults::integrate ( )

References SciFigs::XUniqueYColorLines::divYbyX(), SciFigs::LineLayer::divYbyX(), and TRACE.

{
  TRACE;
  _windowsLayer->divYbyX(2 * M_PI);
  _averageLayer->divYbyX(2 * M_PI);
  _stddevLayer->divYbyX(2 * M_PI);
}

TextEdit* MonoStation::StationResults::label ( ) const [inline]

{return _label;}

void MonoStation::StationResults::load ( QString fileName ) [inline]

Referenced by MonoStation::WinResults::loadResults().

{loadAverage(fileName);}

double MonoStation::StationResults::lowestPeak ( PeakValue pv ) const

References QGpCoreTools::Curve< pointType >::at(), averageCurve(), SciFigs::ParallelBands::band(), SciFigs::ParallelBands::count(), SciFigs::ParallelBand::maximum(), PeakAmplitude, PeakFrequency, TRACE, and QGpCoreTools::Point2D::y().

Referenced by MonoStation::StationLine::setValue().

{
  TRACE;
  int nb=_peakLayer->count()/2;
  ASSERT(nb>0);
  double minF=1e99;
  for(int ib=0; ib<nb; ib++) {
    const ParallelBand& b=_peakLayer->band(2*ib);
    if(b.maximum()<minF) {
      minF=b.maximum();
    }
  }
  switch(pv) {
  case PeakFrequency:
    return minF;
  case PeakAmplitude:
    return averageCurve().at(minF).y();
  }
}

double MonoStation::StationResults::maximumAmplitude ( ) const

References SciFigs::LineLayer::boundingRect(), TRACE, and QGpCoreTools::Rect::y2().

{
  TRACE;
  const LineLayer * plot;
  if(_winCount>1) {
    plot=_stddevLayer;
  } else {
    plot=_averageLayer;
  }
  Rect r=plot->boundingRect();
  return 1.20 * r.y2();
}

double MonoStation::StationResults::maximumAmplitudePeak ( PeakValue pv ) const

References QGpCoreTools::Curve< pointType >::at(), averageCurve(), SciFigs::ParallelBands::band(), SciFigs::ParallelBands::count(), SciFigs::ParallelBand::maximum(), PeakAmplitude, PeakFrequency, and QGpCoreTools::Point2D::y().

Referenced by MonoStation::StationLine::setValue().

{
  int nb=_peakLayer->count()/2;
  ASSERT(nb>0);
  double maxF, maxAmpl, f, ampl;
  const Curve<Point2D>& avCurve=averageCurve();
  f=_peakLayer->band(0).maximum();
  maxAmpl=avCurve.at(f).y();
  maxF=f;
  for(int ib=0; ib<nb; ib++) {
    f=_peakLayer->band(2*ib).maximum();
    ampl=avCurve.at(f).y();
    if(ampl>maxAmpl) {
      maxAmpl=ampl;
      maxF=f;
    }
  }
  switch(pv) {
  case PeakFrequency:
    return maxF;
  case PeakAmplitude:
    return maxAmpl;
  }
}

const Curve< Point2D > & MonoStation::StationResults::maximumCurve ( ) const

References SciFigs::LineLayer::line(), and TRACE.

Referenced by comments(), and MonoStation::StatisticResults::studentTest().

{
  TRACE;
  return static_cast<const PlotLine2D *>(_stddevLayer->line(1))->curve();
}

const Curve< Point2D > & MonoStation::StationResults::minimumCurve ( ) const

References SciFigs::LineLayer::line(), and TRACE.

Referenced by comments(), and MonoStation::StatisticResults::studentTest().

{
  TRACE;
  return static_cast<const PlotLine2D *>(_stddevLayer->line(0))->curve();
}

AbstractStation* MonoStation::StationResults::parent ( ) const [inline]

Referenced by MonoStation::StudentTestCurveModel::parent(), and MonoStation::StatisticResults::studentTest().

{return _parent;}

double MonoStation::StationResults::peak	(	int	ib,
		PeakValue	pv
	)		const

References QGpCoreTools::Curve< pointType >::at(), averageCurve(), SciFigs::ParallelBands::band(), SciFigs::ParallelBand::maximum(), PeakAmplitude, PeakFrequency, TRACE, and QGpCoreTools::Point2D::y().

Referenced by MonoStation::AbstractSummary::setAverageValues(), and MonoStation::StationLine::setValue().

{
  TRACE;
  ib*=2;
  ASSERT(ib<_peakLayer->count());
  double f=_peakLayer->band(ib).maximum();
  switch(pv) {
  case PeakFrequency:
    return f;
  case PeakAmplitude:
    return averageCurve().at(f).y();
  }
}

void MonoStation::StationResults::peakChanged ( ) [signal]

Referenced by addPeak(), clearPeaks(), removePeak(), and setPeak().

int MonoStation::StationResults::peakCount ( ) const

References SciFigs::ParallelBands::count(), and TRACE.

Referenced by MonoStation::PeakItemModel::reset(), MonoStation::AbstractSummary::setAverageValues(), and MonoStation::StationLine::setValue().

{
  TRACE;
  return _peakLayer->count()/2;
}

ParallelBands* MonoStation::StationResults::peakLayer ( ) const [inline]

Referenced by MonoStation::WinResultsOptions::setVisibleLayers(), MonoStation::StatisticResults::studentTest(), and MonoStation::WinResultsOptions::visibleLayers().

{return _peakLayer;}

double MonoStation::StationResults::peakMaximum ( int ib ) const

References SciFigs::ParallelBands::band(), SciFigs::ParallelBand::maximum(), and TRACE.

{
  TRACE;
  ib*=2;
  ASSERT(ib<_peakLayer->count());
  return _peakLayer->band(ib+1).maximum();
}

double MonoStation::StationResults::peakMinimum ( int ib ) const

References SciFigs::ParallelBands::band(), SciFigs::ParallelBand::minimum(), and TRACE.

{
  TRACE;
  ib*=2;
  ASSERT(ib<_peakLayer->count());
  return _peakLayer->band(ib).minimum();
}

void MonoStation::StationResults::printAverage ( ) const

References averageCurve(), QGpCoreTools::endl(), QGpCoreTools::Curve< pointType >::toString(), and TRACE.

Referenced by MonoStation::AbstractTool::outputResults().

{
  TRACE;
  App::stream() << averageCurve().toString() << endl;
}

void MonoStation::StationResults::printPeaks ( ) const

References QGpCoreTools::Curve< pointType >::at(), averageCurve(), SciFigs::ParallelBands::band(), SciFigs::ParallelBands::count(), SciFigs::ParallelBand::maximum(), SciFigs::ParallelBand::minimum(), and TRACE.

Referenced by MonoStation::AbstractTool::outputResults().

{
  TRACE;
  int nb=_peakLayer->count()/2;
  ASSERT(nb==_nWindowsForPeaks.count());
  for(int ib=0; ib<nb; ib++) {
    const ParallelBand& b=_peakLayer->band(2*ib);
    printf("%lg\t%lg\t%lg\t%lg\n", b.maximum(), b.minimum(), _peakLayer->band(2*ib+1).maximum(), averageCurve().at(b.maximum()).y());
  }
}

void MonoStation::StationResults::printWindows ( ) const

References TRACE, SciFigs::XUniqueYColorLines::x(), and SciFigs::XUniqueYColorLines::y().

Referenced by MonoStation::AbstractTool::outputResults().

{
  TRACE;
  const double * x=_windowsLayer->x();
  const double * y=_windowsLayer->y();
  for(int ic=0;ic < _winCount;ic++ ) {
    printf( "# Window %i\n", ic);
    for(int is=0;is < _nSamples;is++ ) {
      printf("%lg\t%lg\n", x[is], y[is]);
    }
    y+=_nSamples;
  }
}

void MonoStation::StationResults::removePeak ( int index )

Removes peak of index.

References peakChanged(), SciFigs::ParallelBands::removeBand(), and TRACE.

{
  TRACE;
  _nWindowsForPeaks.remove(index);
  index*=2;
  _peakLayer->removeBand(index); // first one
  _peakLayer->removeBand(index); // second one
  setToolTips();
  emit peakChanged();
}

void MonoStation::StationResults::save	(	QString	fileName,
		QString	log
	)

References QGpCoreTools::log(), MSG_ID, QGpCoreTools::tr(), and TRACE.

{
  TRACE;
  if(fileName.length()>0) {
    QString message;
    QFileInfo fi(fileName);
    if(fi.exists()) {
       message += tr( "File %1 already exists.\n" ).arg(fi.filePath());
    }
    QDir d(fi.absolutePath());
    QFileInfo filog(d.absoluteFilePath(fi.baseName()+".log"));
    if(filog.exists()) {
      message += tr( "File %1 already exists.\n" ).arg(filog.filePath());
    }
    if(!message.isEmpty()) {
      if(Message::warning(MSG_ID, tr( "Saving result files" ),
                                tr( "%1\nDo you want to replace it(them)?" ).arg(message),
                                Message::no(), Message::yes(), true)==Message::Answer0) return;
    }
    saveAverage(fileName);
    saveLog(filog.filePath(), log);
  }
}

void MonoStation::StationResults::setAverageLayer ( )

References averageCurve(), SciFigs::LineLayer::resetLineProperties(), QGpCoreTools::Curve< pointType >::resize(), QGpCoreTools::sqrt(), TRACE, SciFigs::XUniqueYColorLines::x(), and SciFigs::XUniqueYColorLines::y().

{
  TRACE;
  const double * x=_windowsLayer->x();
  const double * y=_windowsLayer->y();
  Curve<Point2D>& meanCurve=averageCurve();
  Curve<Point2D>& minCurve=stddevCurve(0);
  Curve<Point2D>& maxCurve=stddevCurve(1);

  LayerLocker llAverage(_averageLayer);
  LayerLocker llStddev(_stddevLayer);

  meanCurve.resize(_nSamples);
  minCurve.resize(_nSamples);
  maxCurve.resize(_nSamples);
  for(int is=0; is<_nSamples; is++) {
    double lval;
    meanCurve[is].setX(x[is]);
    minCurve[is].setX(x[is]);
    maxCurve[is].setX(x[is]);
    double sum=0.0, sum2=0.0;
    for(int ic=0; ic<_winCount; ic++) {
      lval=log10(y[is+ic*_nSamples]);
      sum+=lval;
      sum2+=lval*lval;
    }
    if(_winCount>0) {
      sum/=(double) _winCount;
      if(_winCount<2) {
        sum2=0.0;
      } else {
        sum2-=sum*sum*(double)_winCount;
        sum2/=(double)(_winCount-1);
        if(sum2<0.0) sum2=0.0; // sum of square>=square of sum except for rounding errors
      }
    }
    double mVal=pow(10.0, sum);
    double sVal=pow(10.0, sqrt(sum2));
    meanCurve[is].setY(mVal);
    minCurve[is].setY(mVal/sVal);
    maxCurve[is].setY(mVal*sVal);
  }
  _averageLayer->resetLineProperties();
  _stddevLayer->resetLineProperties();
}

void MonoStation::StationResults::setCategory ( const QString & c )

References TRACE.

Referenced by MonoStation::WinResults::groupsToCategories(), and MonoStation::WinResults::setCategories().

{
  TRACE;
  _category=c;
  setToolTips();
}

void MonoStation::StationResults::setCoordinates ( const Point & p ) [inline]

{_coordinates=p;}

void MonoStation::StationResults::setGraph ( AxisWindow * w )

References SciFigs::LineLayer::addLine(), SciFigs::GraphContentLayer::addTrackingAction(), SciFigs::PlotLine2D::clone(), SciFigs::Axis::setAutoTicks(), SciFigs::Axis::setMajorTicks(), SciFigs::Axis::setMinorTicks(), SciFigs::Axis::setNumberType(), SciFigs::AbstractLine::setPen(), SciFigs::LineLayer::setReferenceLine(), SciFigs::Axis::setScaleType(), SciFigs::AbstractLine::setSymbol(), SciFigs::Axis::setTitle(), SciFigs::Axis::setTitleInversedScale(), QGpCoreTools::tr(), TRACE, SciFigs::AxisWindow::xAxis(), and SciFigs::AxisWindow::yAxis().

Referenced by MonoStation::WinResults::loadResults().

{
  TRACE;
  w->xAxis()->setTitle( "Frequency (Hz)" );
  w->xAxis()->setTitleInversedScale( "Period (s)" );
  w->xAxis()->setScaleType(Scale::Log);
  w->xAxis()->setAutoTicks(false);
  w->xAxis()->setMajorTicks(2);
  w->xAxis()->setMinorTicks(0.5);

  w->yAxis()->setNumberType(Number::Fixed);
  _t10Layer=new ParallelBands(w); // T10
  _t10Layer->setObjectName("T10");
  _peakLayer=new ParallelBands(w); // Frequency bands
  _peakLayer->setObjectName("f0");
  _windowsLayer=new XUniqueYColorLines(w);
  _windowsLayer->setObjectName("Windows");
  _windowsLayer->addTrackingAction(tr("Reject time windows"), 0, tr("Rejected time windows are set in gray. "
                                   "Hit 'clear' to effectively remove them from the processing."));
  connect(_windowsLayer, SIGNAL(dataSelected(int, const QVector<int>*)), this, SLOT(blackWindows(int, const QVector<int>*)));
  PlotLine2D * line;
  _averageLayer=new LineLayer(w);
  _averageLayer->setObjectName("Average");
  line=new PlotLine2D;
  line->setPen(Pen(Qt::black, 0.6, Qt::SolidLine));
  line->setSymbol(Symbol());
  _averageLayer->setReferenceLine(line);
  _averageLayer->addLine();
  _stddevLayer=new LineLayer(w);
  _stddevLayer->setObjectName("Stddev");
  line=static_cast<PlotLine2D *>(line->clone());
  line->setPen(Pen(Qt::black, 0.6, Qt::DashLine));
  _stddevLayer->setReferenceLine(line);
  _stddevLayer->addLine();
  _stddevLayer->addLine();
}

void MonoStation::StationResults::setLabel ( TextEdit * l ) [inline]

{_label=l;}

void MonoStation::StationResults::setParent ( AbstractStation * p ) [inline]

Referenced by MonoStation::StudentTestCurveModel::setWindowList().

{_parent=p;}

void MonoStation::StationResults::setPeak	(	int	index,
		double	minFreq,
		double	maxFreq
	)

Sets peak of index to be between minFreq and maxFreq.

References peakChanged(), TRACE, and SciFigs::XUniqueYColorLines::x().

Referenced by addPeak().

{
  TRACE;
  if(_winCount<2) return;
  if(minFreq>0.0 && maxFreq>0.0) {
    if(minFreq>maxFreq) {
      double tmp=minFreq;
      minFreq=maxFreq;
      maxFreq=tmp;
    }
    const double * x=_windowsLayer->x();
    int iminFreq=frequency2Index(x, minFreq);
    int imaxFreq=frequency2Index(x, maxFreq);
    setPeak(index, iminFreq, imaxFreq);

  }
  setToolTips();
  emit peakChanged();
}

void MonoStation::StationResults::setPeakLayer ( )

Init the frequency average layer: try to calculate at least one peak.

References addPeak(), averageCurve(), clearPeaks(), TRACE, and SciFigs::XUniqueYColorLines::x().

{
  TRACE;
  if(_winCount==0) return ;
  double minFreq, maxFreq;
  const double * x=_windowsLayer->x();
  int imax=averageMax(averageCurve());
  if(imax==-1) {
    minFreq=x[0 ];
    maxFreq=x[_nSamples-1];
  } else {
    double totalMinFreq=x[ 0 ];
    double medFreq=x[ imax ];
    double sigma=1.5-0.25*(medFreq-totalMinFreq) /
                 (x[_nSamples-1]-totalMinFreq);
    minFreq=medFreq/sigma;
    maxFreq=medFreq*sigma;
  }
  clearPeaks();
  addPeak(minFreq, maxFreq);
  setToolTips();
}

void MonoStation::StationResults::setStationName ( const QString & n ) [inline]

{_stationName=n;}

void MonoStation::StationResults::setT10Layer ( double averageWindowLength )

References SciFigs::ParallelBands::addBand(), SciFigs::ParallelBands::clear(), and TRACE.

{
  TRACE;
  if(averageWindowLength> 0.0) {
    _t10Layer->clear();
    _t10Layer->addBand(-1e99, 10.0/averageWindowLength,
                       QBrush(QColor( 220, 154, 179), Qt::BDiagPattern));
  }
}

void MonoStation::StationResults::setVisibleLayers ( int visibleLayers )

References SciFigs::GraphContentLayer::setOpacity(), showColors(), and TRACE.

{
  TRACE;
  // vector visibleLayers, is defined by the general preferences
  // Hide corresponding layers
  bool winVis=false;
  bool b=visibleLayers & 0x01;
  _t10Layer->setOpacity(b ? 1.0 : 0.0);
  b=visibleLayers & 0x02;
  _peakLayer->setOpacity(b ? 1.0 : 0.0);
  b=visibleLayers & 0x04;
  if(b) winVis=true;
  _windowsLayer->setOpacity(b ? 1.0 : 0.0);
  b=visibleLayers & 0x08;
  _averageLayer->setOpacity(b ? 1.0 : 0.0);
  b=visibleLayers & 0x10;
  _stddevLayer->setOpacity(b ? 1.0 : 0.0);
  emit showColors(winVis);
}

void MonoStation::StationResults::setWindow	(	int	winIndex,
		DoubleSignal *	sig
	)

References GeopsyCore::DoubleSignal::interpoleAt(), TRACE, SciFigs::XUniqueYColorLines::x(), and SciFigs::XUniqueYColorLines::y().

{
  TRACE;
  ASSERT(winIndex < _winCount);
  const double * x=_windowsLayer->x();
  double * y=_windowsLayer->y();
  int di=winIndex * _nSamples;
  LayerLocker ll(_windowsLayer);
  for(int i=0;i < _nSamples;i++ )
    y[ i+di ]=sig->interpoleAt(x[ i ] );
}

void MonoStation::StationResults::setWindowColor	(	int	winIndex,
		const QColor &	col
	)

References SciFigs::XUniqueYColorLines::setColor().

{
  _windowsLayer->setColor(winIndex, col);
}

void MonoStation::StationResults::setWindowColor	(	const QVector< int > *	selCurves,
		const QColor &	col
	)

References SciFigs::AxisWindow::deepUpdate(), SciFigs::GraphContentLayer::graph(), SciFigs::XUniqueYColorLines::setColor(), and TRACE.

{
  TRACE;
  QVector<int>::const_iterator it;
  for(it=selCurves->begin(); it!=selCurves->end(); ++it) {
    _windowsLayer->setColor( *it, col);
  }
  _windowsLayer->graph()->deepUpdate();
}

void MonoStation::StationResults::setWindows	(	int	winCount,
		SamplingParameters &	samp
	)

References SciFigs::XUniqueYColorLines::clear(), QGpCoreTools::SamplingParameters::count(), SciFigs::XUniqueYColorLines::setColors(), SciFigs::XUniqueYColorLines::setLineWeight(), SciFigs::XUniqueYColorLines::setPointCount(), TRACE, QGpCoreTools::SamplingParameters::value(), and SciFigs::XUniqueYColorLines::x().

{
  TRACE;
  _nSamples=samp.count();
  // This power of 2 is used by frequency2Index()
  _nSamples2=1;
  while(_nSamples2 < _nSamples) _nSamples2=_nSamples2 << 1;
  _winCount=winCount;

  _windowsLayer->clear();
  _windowsLayer->setPointCount(_winCount, _nSamples);
  _windowsLayer->setColors(new QColor[_winCount] );
  _windowsLayer->setLineWeight(0.02);

  // Init the frequency axis
  double * f=_windowsLayer->x();
  LayerLocker ll(_windowsLayer);
  for(int is=0;is < _nSamples;is++ ) {
    f[ is ]=samp.value(is);
  }
}