#include <ToolLinearFKActived.h>

Public Slots
void	on_slowType_activated (int index)
Signals
void	slowTypeChanged ()
Public Member Functions
void	getParameters (LinearFKParameters &param)
void	setParameters (const LinearFKParameters &param)
void	setSlownessType ()
	ToolLinearFKActived (QWidget *parent=0, Qt::WFlags fl=0)

Constructor & Destructor Documentation

ToolLinearFKActived::ToolLinearFKActived	(	QWidget *	parent = `0`,
		Qt::WFlags	fl = `0`
	)

Constructs a ToolLinearFKActived as a child of 'parent', with the name 'name' and widget flags set to 'f'.

References setSlownessType(), QGpCoreTools::tr(), TRACE, ArrayCore::LinearFKParameters::xSampling(), and ArrayCore::LinearFKParameters::ySampling().

    : QWidget(parent, fl)
{
  TRACE;
  setupUi(this);

  normalization->setExternalRange();

  LinearFKParameters param;

  xSampling->setUnit(tr(" Hz"));
  xSampling->setPrecision(2);
  xSampling->setSingleStep(0.25);
  xSampling->setAdmissibleRange(1e-99, 1e99);
  xSampling->setParameters(param.xSampling());

  slowType->setCurrentIndex(0);
  setSlownessType();
  ySampling->setPrecision(5);    // Avoid rounding errors when reloading parameters
  ySampling->setParameters(param.ySampling());

  timeLimits->removeUseFirstOnly();

  curves->setProxy(new DispersionProxy);
}

Member Function Documentation

void ToolLinearFKActived::getParameters ( LinearFKParameters & param )

{
  TRACE;
  timeLimits->getParameters(param.timeRange());
  windowShape->getParameters(param.taper());
  xSampling->getParameters(param.xSampling());
  ySampling->getParameters(param.ySampling());
  if(slowType->currentIndex()==0) {
    param.setYSamplingType(LinearFKParameters::Slowness);
  } else {
    param.setYSamplingType(LinearFKParameters::Velocity);
    param.ySampling().inverse(); // Internally always stored in slowness
  }
  if(normalizationGroup->isChecked()) {
    normalization->getParameters(param.normalization());
    param.normalization().setRange(param.xSampling().minimum(),
                                   param.xSampling().maximum());
  } else {
    param.normalization().setType(NormalizationParameters::None);
  }
  param.setFrequencySmoothingFactor(frequencySmoothingFactor->value());
  param.setFrequencyBandwidth(frequencyBandwidth->value());
  param.setMinimumDistance(minDistance->value());
  param.setMaximumDistance(maxDistance->value());
  if(rawBeamPowerNorm->isChecked()) {
    param.setBeamPowerNormalization(LinearFKParameters::Raw);
  } else if(spectrumBeamPowerNorm->isChecked()) {
    param.setBeamPowerNormalization(LinearFKParameters::Spectrum);
  } else {
    param.setBeamPowerNormalization(LinearFKParameters::Maximum);
  }
  param.setHighResolution(hrParamGroup->isChecked());
  if(doDampingFactor->isChecked()) {
    param.setDampingFactor(dampingFactorEdit->value());
  } else {
    param.setDampingFactor(0.0);
  }
}

void ToolLinearFKActived::on_slowType_activated ( int index ) [slot]

References setSlownessType(), and TRACE.

{
  TRACE;
  ySampling->setPrecision(5);                   // Avoid rounding errors
  ySampling->setAdmissibleRange(1e-99, 1e99);
  ySampling->setInversed(index==1);
  setSlownessType();
}

void ToolLinearFKActived::setParameters ( const LinearFKParameters & param )

{
  TRACE;
  timeLimits->setParameters(param.timeRange());
  windowShape->setParameters(param.taper());
  SamplingParameters y=param.ySampling();
  switch(param.ySamplingType()) {
  case LinearFKParameters::Slowness:
    slowType->setCurrentIndex(0);
    break;
  case LinearFKParameters::Velocity:
    slowType->setCurrentIndex(1);
    y.inverse();
    break;
  }
  xSampling->setParameters(param.xSampling());
  ySampling->setParameters(y);
  if(param.normalization().type()==NormalizationParameters::None) {
    normalizationGroup->setChecked(false);
  } else {
    normalizationGroup->setChecked(true);
    normalization->setParameters(param.normalization());
  }
  frequencySmoothingFactor->setValue(param.frequencySmoothingFactor());
  frequencyBandwidth->setValue(param.frequencyBandwidth());
  minDistance->setValue(param.minimumDistance());
  maxDistance->setValue(param.maximumDistance());
  switch(param.beamPowerNormalization()) {
  case LinearFKParameters::Raw:
    rawBeamPowerNorm->setChecked(true);
    break;
  case LinearFKParameters::Spectrum:
    spectrumBeamPowerNorm->setChecked(true);
    break;
  case LinearFKParameters::Maximum:
    maxBeamPowerNorm->setChecked(true);
    break;
  }
  hrParamGroup->setChecked(param.highResolution());
  if(param.dampingFactor()>0.0) {
    doDampingFactor->setChecked(true);
    dampingFactorEdit->setValue(param.dampingFactor());
  } else {
    doDampingFactor->setChecked(false);
  }
}

void ToolLinearFKActived::setSlownessType ( )

References slowTypeChanged(), QGpCoreTools::tr(), and TRACE.

Referenced by on_slowType_activated(), ToolLinearFKActived(), and ToolLinearFKActive::updateAllFields().

{
  TRACE;
  ySampling->blockSignals(true);
  if(slowType->currentIndex()==0) {  // Slowness
    ySampling->setUnit(tr(" s/m"));
    ySampling->setPrecision(5);
    ySampling->setSingleStep(0.001);
    ySampling->setAdmissibleRange(1e-99, 1e99);
  } else {         // Velocity
    ySampling->setUnit(tr(" m/s"));
    ySampling->setPrecision(0);
    ySampling->setSingleStep(10.0);
    ySampling->setAdmissibleRange(1.0, 1e99);
  }
  ySampling->blockSignals(false);
  emit slowTypeChanged();
}

void ToolLinearFKActived::slowTypeChanged ( ) [signal]

Referenced by setSlownessType().

The documentation for this class was generated from the following files:

geopsyarray/ToolLinearFKActived.h
geopsyarray/ToolLinearFKActived.cpp

Public Slots

Signals

Public Member Functions

Constructor & Destructor Documentation

Member Function Documentation