Public Slots | Public Member Functions | Protected Slots | Protected Member Functions | Protected Attributes
ToolFK Class Reference

#include <ToolFK.h>

Inheritance diagram for ToolFK:
ToolArrayBase GeopsyGui::ToolBase ToolHRFK ToolLinearFKPassive

List of all members.

Public Slots

virtual void start ()
void stop ()
virtual void test ()

Public Member Functions

virtual bool initStations (SubSignalPool *subPool)
virtual void setParameters (int &argc, char **argv)
 ToolFK (QWidget *parent)
virtual void waitFinished ()
 ~ToolFK ()

Protected Slots

void finish ()
void gridChanged ()
void kmaxChanged ()
void parametersChanged ()
void setComputedKmax ()
void setTemporaryKmax ()

Protected Member Functions

bool checkParameters (FKParameters *param) const
virtual AbstractParameters * parameters (AbstractParameters *param=0) const
void setDefaultGridParameters ()
virtual void setDefaultGridSize (double kmax)
virtual void setDefaultGridStep (double kmin)
virtual void setParameters (const AbstractParameters *param)
void startLoop (FKLoop *loop, FKParameters *param, const QString &message=QString::null)
virtual const char * toolName ()
virtual void updateAllFields ()

Protected Attributes

QTime _chrono
ToolFKd * _d
bool _exportAllFKGrids
KmaxSolver * _kmaxSolver
QTimer _kmaxTimer
bool _kmaxTouched
bool _kminTouched
FKLoop * _loop
FKParameters * _param

Constructor & Destructor Documentation

ToolFK::ToolFK ( QWidget *  parent)

References _d, _exportAllFKGrids, _kmaxSolver, _kmaxTouched, _kminTouched, _loop, gridChanged(), kmaxChanged(), GeopsyGui::ToolBase::loadLogParameters(), parametersChanged(), GeopsyGui::ToolBase::setWindowTitle(), start(), stop(), test(), and TRACE.

                               :
    ToolArrayBase(parent, 1)
{
  TRACE;
  setWindowIcon(QIcon(":/images/fk-22x22.png"));
  setObjectName("ToolFK");
  QVBoxLayout * baseLayout=new QVBoxLayout(this);
  _d=new ToolFKd(this);
  baseLayout->addWidget(_d);
  _exportAllFKGrids=false;

  setWindowTitle("FK toolbox");

  connect(_d->startBut, SIGNAL(clicked()), this, SLOT(start()) );
  connect(_d->stopBut, SIGNAL(clicked()), this, SLOT(stop()) );
  connect(_d->testBut, SIGNAL(clicked()), this, SLOT(test()) );
  connect(_d->loadParam, SIGNAL(clicked()), this, SLOT(loadLogParameters()) );
  connect(_d->freqSamp, SIGNAL(sampleCountChanged()), _d, SLOT(numFreqChanged()) );

  connect(_d->winParam, SIGNAL(parametersChanged()), this, SLOT(parametersChanged()) );
  connect(_d->timeLimits, SIGNAL(parametersChanged()), this, SLOT(parametersChanged()) );
  connect(_d->testFrequency, SIGNAL(valueChanged( const QString& )), this, SLOT(parametersChanged()) );
  connect(_d->freqBandwidth, SIGNAL(valueChanged( const QString& )), this, SLOT(parametersChanged()) );

  connect(_d->kminEdit, SIGNAL(valueChanged(const QString& )), this, SLOT(gridChanged()));
  connect(_d->kmaxEdit, SIGNAL(valueChanged(const QString& )), this, SLOT(kmaxChanged()));
  connect(_d->vminEdit, SIGNAL(valueChanged(const QString& )), this, SLOT(gridChanged()));

  _kmaxSolver=0;
  _kmaxTouched=false;
  _kminTouched=false;
  _loop=0;
}
ToolFK::~ToolFK ( )

References _kmaxSolver, ArrayCore::KmaxSolver::terminate(), and TRACE.

{
  TRACE;
  if(_kmaxSolver) {
    _kmaxSolver->terminate();
    delete _kmaxSolver;
  }
}

Member Function Documentation

bool ToolFK::checkParameters ( FKParameters *  param) const [protected]

References ArrayCore::ArrayParameters::frequencyBandWidth(), ArrayCore::FKParameters::maximumWaveNumber(), ArrayCore::FKParameters::minimumWaveNumber(), MSG_ID, and QGpCoreTools::tr().

Referenced by parameters().

{
  if(param->frequencyBandWidth()<=0) {
    Message::warning(MSG_ID,tr("FK parameters"),tr("Band width cannot be null or negative."), true);
    return false;
  }
  if(param->minimumWaveNumber()>param->maximumWaveNumber()) {
    Message::warning(MSG_ID,tr("FK parameters"),tr("kmin must be less than kmax."), true);
    return false;
  }
  if(param->minimumWaveNumber()<=0.0) {
    Message::warning(MSG_ID,tr("FK parameters"),tr("kmin cannot be null or negative."), true);
    return false;
  }
  if(param->minimumWaveNumber()*3600<param->maximumWaveNumber()) {
    Message::warning(MSG_ID,tr("FK parameters"),tr("kmin cannot be more than 3600 times smaller than kmax. "
                                                  "If kmin*3600==kmax, the approximate size of a FK map is 100 Mb."), true);
    return false;
  }
  return true;
}
void ToolFK::finish ( ) [protected, slot]

References _chrono, _d, ToolArrayBase::_log, _loop, _param, ArrayCore::ArrayParameters::outputFile(), ToolFKd::setRunning(), QGpCoreTools::tr(), GeopsyGui::ToolBase::unlockSubPool(), and ToolArrayBase::writeProcessLogs().

Referenced by ToolLinearFKPassive::finishPositive(), ToolHRFK::start(), and start().

{
  QTime timeElapsed(0,0);
  _log += tr("Process run in %1\n").arg(timeElapsed.addMSecs(_chrono.elapsed()).toString("hh:mm:ss"));
  _log += tr("Process ended at %1\n").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"));
  delete _loop;
  _loop=0;
  writeProcessLogs(_param->outputFile());
  unlockSubPool();
  _param=0;
  _d->setRunning(false);
}
void ToolFK::gridChanged ( ) [protected, slot]

References _d, _fkBrowser, parameters(), and TRACE.

Referenced by kmaxChanged(), setDefaultGridSize(), and ToolFK().

{
  TRACE;
  if(_fkBrowser && _d->testBut->isChecked()) {
    FKParameters * param=static_cast<FKParameters *>(parameters());
    if(param) {
      _fkBrowser->setGrid(param);
      delete param;
    }
  }
}
bool ToolFK::initStations ( SubSignalPool *  subPool) [virtual]

Reimplemented from GeopsyGui::ToolBase.

Reimplemented in ToolLinearFKPassive.

References ToolArrayBase::_array, _d, GeopsyGui::ToolBase::_subPool, ToolArrayBase::initStations(), ArrayCore::ArrayStations::setRelativeCoordinates(), TRACE, and GeopsyGui::ToolBase::updateSubPool().

Referenced by ToolLinearFKPassive::initStations().

{
  TRACE;
  if(!ToolArrayBase::initStations(subPool, _d->winParam)) return false;
  _d->timeLimits->setPicks(_subPool);
  _array.setRelativeCoordinates();
  emit updateSubPool();
  return true;
}
void ToolFK::kmaxChanged ( ) [protected, slot]

References _kmaxSolver, _kmaxTouched, gridChanged(), MSG_ID, QGpCoreTools::tr(), and TRACE.

Referenced by ToolFK().

{
  TRACE;
  if(_kmaxSolver) {
    if(Message::question(MSG_ID, tr("Changing grid size"),
                         tr("The grid size is currently been computed, do you want to "
                            "stop this computation and set your own value?"),
                         Message::yes(), Message::no())==Message::Answer0) {
      _kmaxTouched=true;
    }
  }
  gridChanged();
}
AbstractParameters * ToolFK::parameters ( AbstractParameters *  param = 0) const [protected, virtual]

Reimplemented from GeopsyGui::ToolBase.

Reimplemented in ToolHRFK.

References _d, checkParameters(), ToolFKd::getParameters(), and TRACE.

Referenced by gridChanged(), parametersChanged(), ToolLinearFKPassive::start(), and start().

{
  TRACE;
  if(!param) {
    param=new FKParameters;
  }
  _d->getParameters(*static_cast<FKParameters *>(param));
  if(!checkParameters(static_cast<FKParameters *>(param))) {
    delete param;
    return 0;
  } else {
    return param;
  }
}
void ToolFK::parametersChanged ( ) [protected, slot]

References _d, _fkBrowser, and parameters().

Referenced by ToolHRFK::test(), test(), ToolFK(), and ToolHRFK::ToolHRFK().

{
  if(_fkBrowser && _d->testBut->isChecked()) {
    FKParameters * param=static_cast<FKParameters *>(parameters());
    if(param) _fkBrowser->setParameters(_d->testFrequency->value(), param);
  }
}
void ToolFK::setComputedKmax ( ) [protected, slot]

References _kmaxSolver, _kmaxTimer, _kmaxTouched, ArrayCore::KmaxSolver::kmax(), setDefaultGridSize(), and TRACE.

Referenced by setDefaultGridParameters().

{
  TRACE;
  // Upon termination, _kmaxSolver might be replaced by another solver
  // and this function called by an old event still in the stack
  // Make sure that it still refers to the current solver.
  KmaxSolver * solver=qobject_cast<KmaxSolver *>(sender());
  if(solver && _kmaxSolver==solver) {
    if(!_kmaxTouched) {
      bool ok;
      double kmax=_kmaxSolver->kmax(ok);
      if(ok) {
        setDefaultGridSize(kmax);
      }
    }
    _kmaxTimer.stop();
    _kmaxSolver->deleteLater();
    _kmaxSolver=0;
  }
}
void ToolFK::setDefaultGridParameters ( ) [protected]

References ToolArrayBase::_array, _kmaxSolver, _kmaxTimer, _kmaxTouched, _kminTouched, ArrayCore::KminSolver::calculate(), ArrayCore::KmaxSolver::calculate(), QGpCoreTools::endl(), ArrayCore::ArrayStations::relativeCoordinates(), setComputedKmax(), setDefaultGridStep(), setTemporaryKmax(), ArrayCore::KmaxSolver::terminate(), QGpCoreTools::tr(), and TRACE.

Referenced by updateAllFields().

{
  TRACE;
  if(_kmaxSolver) {
    _kmaxSolver->terminate();
    _kmaxSolver->deleteLater();
    _kmaxSolver=0;
  }

  QVector<Point2D> stations;
  for(int i=0;i<_array.count();i++) {
    stations.append(Point2D(_array.relativeCoordinates(i)));
  }
  // Estimate kmin and kmax from station coordinates
  KminSolver kminSolver(stations);
  bool ok=true;
  double kmin=kminSolver.calculate(ok);
  if(!_kmaxTouched) {
    if (ok && kmin>0.0) {
      _kmaxSolver=new KmaxSolver(stations, kmin);
      connect(&_kmaxTimer, SIGNAL(timeout()), this, SLOT(setTemporaryKmax()));
      connect(_kmaxSolver, SIGNAL(finished()), this, SLOT(setComputedKmax()));
      _kmaxSolver->calculate();
      _kmaxTimer.start(1000);
    } else {
      App::stream() << tr("Error computing kmin for station coordinates") << endl;
      return;
    }
  }
  if(!_kminTouched) {
    setDefaultGridStep(kmin);
  }
}
void ToolFK::setDefaultGridSize ( double  kmax) [protected, virtual]

References _d, gridChanged(), and TRACE.

Referenced by setComputedKmax(), and setTemporaryKmax().

{
  TRACE;
  _d->kmaxEdit->blockSignals(true);
  kmax*=2.0;
  // Check if enough precision to represent these numbers, at least 3 significant digits
  if(kmax<pow(10.0, -_d->kmaxEdit->decimals())) {
    _d->kmaxEdit->setDecimals(3-floor(log10(kmax)));
  }
  // Set value
  _d->kmaxEdit->setValue(kmax);
  _d->kmaxEdit->blockSignals(false);
  gridChanged();
}
void ToolFK::setDefaultGridStep ( double  kmin) [protected, virtual]

Reimplemented in ToolHRFK.

References _d, and TRACE.

Referenced by setDefaultGridParameters().

{
  TRACE;
  kmin*=0.25;
  // Check if enough precision to represent these numbers, at least 3 significant digits
  if(kmin<pow(10.0, -_d->kminEdit->decimals())) {
    _d->kminEdit->setDecimals(3-floor(log10(kmin)));
  }
  // Set value
  _d->kminEdit->setValue(kmin);
}
void ToolFK::setParameters ( int &  argc,
char **  argv 
) [virtual]

By default loads parameters values from current settings. If you redefine this function do not forget to call this version before doing anything else.

Reimplemented from GeopsyGui::ToolBase.

References _d, _exportAllFKGrids, GeopsyGui::ToolBase::loadLogParameters(), ToolFKd::setOutputFileChecked(), and TRACE.

{
  TRACE;
  ToolBase::setParameters(argc, argv);
  int i, j=1;
  for(i=1; i<argc; i++) {
    QByteArray arg=argv[i];
    if(arg[0]=='-') {
      if(arg=="-param") {
        CoreApplication::checkOptionArg(i, argc, argv);
        loadLogParameters(argv[i] );
      } else if(arg=="-export-grids") {
        _exportAllFKGrids=true;
      } else if(arg=="-f") {
        _d->setOutputFileChecked(true);
      } else {
        argv[j++]=argv[i];
      }
    } else {
      argv[j++]=argv[i];
    }
  }
  if(j < argc) {
    argv[j]=0;
    argc=j;
  }
}
void ToolFK::setParameters ( const AbstractParameters *  param) [protected, virtual]

Reimplemented from GeopsyGui::ToolBase.

Reimplemented in ToolHRFK.

References _d, ToolFKd::setParameters(), and TRACE.

{
  TRACE;
  _d->setParameters(*static_cast<const FKParameters *>(param));
}
void ToolFK::setTemporaryKmax ( ) [protected, slot]

References _d, _kmaxSolver, _kmaxTimer, _kmaxTouched, ToolFKd::getParameters(), ArrayCore::KmaxSolver::kmax(), QGpCoreTools::SamplingParameters::maximum(), setDefaultGridSize(), ArrayCore::KmaxSolver::terminate(), and TRACE.

Referenced by setDefaultGridParameters().

{
  TRACE;
  if(_kmaxTouched) {
    _kmaxTimer.stop();
    _kmaxSolver->terminate();
    _kmaxSolver->deleteLater();
    _kmaxSolver=0;
  }
  if(_kmaxSolver) {
    bool ok;
    double kmax=_kmaxSolver->kmax(ok);
    if(ok) {
      // TODO: implement the maximum allowed K in KmaxSolver
      SamplingParameters param;
      _d->freqSamp->getParameters(param);
      double maxK=2.0*M_PI*param.maximum()/_d->vminEdit->value();
      if(kmax>=maxK) {
        kmax=maxK;
        _kmaxTimer.stop();
        _kmaxSolver->terminate();
        _kmaxSolver->deleteLater();
        _kmaxSolver=0;
      }
      setDefaultGridSize(kmax);
    }
  }
}
void ToolFK::start ( ) [virtual, slot]

Reimplemented from GeopsyGui::ToolBase.

Reimplemented in ToolHRFK, and ToolLinearFKPassive.

References ToolArrayBase::_array, _d, _exportAllFKGrids, ToolArrayBase::_log, finish(), ToolFKd::outputFile(), parameters(), ToolArrayBase::resetLogs(), FKLoop::setArray(), ArrayCore::FKParameters::setExportAllFKGrids(), FKLoop::setLog(), ArrayCore::ArrayParameters::setOutputFile(), FKLoop::setParameters(), startLoop(), GeopsyGui::ToolBase::subPoolLocked(), and TRACE.

Referenced by ToolFK().

{
  TRACE;
  if(subPoolLocked()) return;
  resetLogs();
  // Get parameters from dialog box
  FKParameters * param=static_cast<FKParameters *>(parameters());
  if(!param) return;
  param->setOutputFile(_d->outputFile());
  param->setExportAllFKGrids(_exportAllFKGrids);
  // Prepare loop
  FKLoop *loop=new FKLoop;
  loop->setArray(&_array);
  loop->setLog(&_log);
  if( !loop->setParameters(param) ) {
    delete loop;
    return ;
  }
  connect(loop, SIGNAL(finished()), this, SLOT(finish()));
  startLoop(loop, param);
}
void ToolFK::startLoop ( FKLoop *  loop,
FKParameters *  param,
const QString &  message = QString::null 
) [protected]

message is displayed at the top while running. If empty, 'Runnning...' is displayed.

References _chrono, _d, ToolArrayBase::_log, _loop, _param, QGpCoreTools::SamplingParameters::count(), ArrayCore::ArrayParameters::frequencySampling(), GeopsyGui::ToolBase::lockSubPool(), ArrayCore::ArrayParameters::outputFile(), ToolFKd::setRunning(), QGpCoreTools::ParallelLoop::start(), QGpCoreTools::tr(), and ToolArrayBase::writeParameterLogs().

Referenced by ToolLinearFKPassive::start(), ToolHRFK::start(), and start().

{
  _d->detailedStatus->setLoop(loop);
  _loop=loop;
  _param=param;
  // Start main loop
  lockSubPool(); // Prevent any change on the orignal signals
  _d->setRunning(true, message);
  writeParameterLogs(_param->outputFile());
  _log += tr("Process started at %1\n").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"));
  _chrono.start();
  _loop->start(0, _param->frequencySampling().count());
}
void ToolFK::stop ( ) [slot]

References _loop, QGpCoreTools::ParallelLoop::terminate(), and TRACE.

Referenced by ToolFK().

{
  TRACE;
  if(_loop) {
    _loop->terminate();
  }
}
void ToolFK::test ( ) [virtual, slot]

Reimplemented in ToolHRFK.

References ToolArrayBase::_array, GeopsyGui::ToolBase::_childrenList, _fkBrowser, GeopsyCore::geopsyCore, geopsyGui, parametersChanged(), ToolArrayBase::setTimeWindowLayer(), GeopsyCore::GeopsyCoreEngine::showMessage(), GeopsyGui::ToolBase::timeWindowLayer(), QGpCoreTools::tr(), and TRACE.

Referenced by ToolFK().

{
  TRACE;
  if(!_fkBrowser) {
    _childrenList[0]=new FKTimeWindows;
    _fkBrowser->setObjectName("FKBrowser");
    _fkBrowser->setArray(_array);
    _fkBrowser->setTimeWindowLayer(timeWindowLayer());
    setTimeWindowLayer(_fkBrowser->timeWindowList());
    geopsyGui->addWindow(_fkBrowser);
  }
  geopsyGui->showWindow(_fkBrowser);
  QApplication::processEvents();
  parametersChanged();
  geopsyCore->showMessage(tr("Signals are ready"));
}
const char * ToolFK::toolName ( ) [protected, virtual]

Implements ToolArrayBase.

Reimplemented in ToolHRFK, and ToolLinearFKPassive.

{
  return "FK Array analysis";
}
void ToolFK::updateAllFields ( ) [protected, virtual]

Reimplemented from GeopsyGui::ToolBase.

References _d, ToolFKd::numFreqChanged(), ToolFKd::on_freqScroll_valueChanged(), setDefaultGridParameters(), and TRACE.

{
  TRACE;
  _d->winParam->updateAllFields();
  _d->timeLimits->updateAllFields();
  _d->numFreqChanged();
  _d->on_freqScroll_valueChanged(0);
  // After restoring last values from registry
  setDefaultGridParameters();
}
void ToolFK::waitFinished ( ) [virtual]

Reimplemented from GeopsyGui::ToolBase.

References _loop, TRACE, and QGpCoreTools::ParallelLoop::waitFinished().

{
  TRACE;
  if(_loop) {
    _loop->waitFinished();
  }
}

Member Data Documentation

QTime ToolFK::_chrono [protected]

Referenced by finish(), and startLoop().

ToolFKd* ToolFK::_d [protected]

Referenced by finish(), ToolLinearFKPassive::finishPositive(), gridChanged(), initStations(), parameters(), parametersChanged(), setDefaultGridSize(), setDefaultGridStep(), ToolHRFK::setParameters(), setParameters(), setTemporaryKmax(), ToolLinearFKPassive::start(), ToolHRFK::start(), start(), startLoop(), ToolFK(), ToolHRFK::ToolHRFK(), and updateAllFields().

bool ToolFK::_exportAllFKGrids [protected]

Referenced by setParameters(), ToolHRFK::start(), start(), and ToolFK().

KmaxSolver* ToolFK::_kmaxSolver [protected]

Referenced by kmaxChanged(), setComputedKmax(), setDefaultGridParameters(), setTemporaryKmax(), ToolFK(), and ~ToolFK().

QTimer ToolFK::_kmaxTimer [protected]

Referenced by setComputedKmax(), setDefaultGridParameters(), and setTemporaryKmax().

bool ToolFK::_kmaxTouched [protected]

Referenced by kmaxChanged(), setComputedKmax(), setDefaultGridParameters(), setTemporaryKmax(), and ToolFK().

bool ToolFK::_kminTouched [protected]

Referenced by setDefaultGridParameters(), and ToolFK().

FKLoop* ToolFK::_loop [protected]

Referenced by finish(), ToolLinearFKPassive::finishPositive(), startLoop(), stop(), ToolFK(), and waitFinished().

FKParameters* ToolFK::_param [protected]

Referenced by finish(), ToolLinearFKPassive::finishPositive(), and startLoop().

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines

Modified 2013-10-22

Valid CSS! Valid XHTML 1.0!