#include <WindowingParameters.h>

Inheritance diagram for GeopsyCore::WindowingParameters:

Classes
struct	ShortLongTermAverage
Public Types
enum	LengthType { Exactly, AtLeast, FrequencyDependent }
enum	SampleThreshold { NoSampleThreshold, RelativeSampleThreshold, AbsoluteSampleThreshold }
Public Member Functions
const double &	badSampleThreshold () const
SampleThreshold	badSampleThresholdType () const
QString	badSampleThresholdTypeString () const
const double &	badSampleTolerance () const
virtual void	collectKeywords (PARAMETERS_COLLECTKEYWORDS_ARGS)
int	componentCount () const
const FilterParameters &	filter () const
bool	filterComponent (int comp) const
const ShortLongTermAverage &	filterSignalAntiTrigger () const
bool	filterStation (int stat) const
bool	isValid ()
virtual int	keywordCount (PARAMETERS_KEYWORDCOUNT_ARGS)
LengthType	lengthType () const
QString	lengthTypeString () const
double	maximumLength (double frequency) const
double	minimumLength (double frequency) const
void	operator= (const WindowingParameters &o)
const double &	overlap () const
double	periodCount () const
void	printDebug ()
bool	rawComponent (int comp) const
const ShortLongTermAverage &	rawSignalAntiTrigger () const
bool	rawStation (int stat) const
void	setBadSampleThreshold (const double &b)
void	setBadSampleThresholdType (SampleThreshold t)
void	setBadSampleThresholdType (const QString &t)
void	setBadSampleTolerance (const double &b)
void	setComponentCount (int n)
void	setFilter (const FilterParameters &f)
void	setFilterComponent (int comp, bool b)
void	setFilterSignalAntiTrigger (const ShortLongTermAverage &f)
void	setFilterStation (int stat, bool b)
void	setLength (double tmin, double tmax)
void	setLength (double t)
void	setLengthType (const QString &l)
void	setOverlap (const double &o)
void	setPeriodCount (double n)
void	setRawComponent (int comp, bool b)
void	setRawSignalAntiTrigger (const ShortLongTermAverage &r)
void	setRawStation (int stat, bool b)
void	setStationCount (int n)
virtual bool	setValue (PARAMETERS_SETVALUE_ARGS)
int	stationCount () const
virtual QString	toString (PARAMETERS_TOSTRING_ARGS_DECL) const
	WindowingParameters ()
	~WindowingParameters ()

Member Enumeration Documentation

enum GeopsyCore::WindowingParameters::LengthType

Enumerator:

Exactly
AtLeast
FrequencyDependent

{Exactly, AtLeast, FrequencyDependent};

enum GeopsyCore::WindowingParameters::SampleThreshold

Enumerator:

NoSampleThreshold
RelativeSampleThreshold
AbsoluteSampleThreshold

{NoSampleThreshold, RelativeSampleThreshold, AbsoluteSampleThreshold};

Constructor & Destructor Documentation

GeopsyCore::WindowingParameters::WindowingParameters ( )

References GeopsyCore::WindowingParameters::ShortLongTermAverage::enabled, Exactly, RelativeSampleThreshold, and TRACE.

{
  TRACE;
  _componentCount=0;
  _stationCount=0;
  _rawComponent=0;
  _filterComponent=0;
  _rawStation=0;
  _filterStation=0;
  _overlap=0.0;
  _badSampleThresholdType=RelativeSampleThreshold;
  _badSampleThresholdValue=100.0;
  _badSampleTolerance=0.0;
  _rawSignalAntiTrigger.enabled=false;
  _filterSignalAntiTrigger.enabled=false;
  _lengthType=Exactly;
  _minimumLength=0.0;
  _maximumLength=0.0;
  _periodCount=0.0;
}

GeopsyCore::WindowingParameters::~WindowingParameters ( )

References TRACE.

{
  TRACE;
  delete [] _rawComponent;
  delete [] _filterComponent;
  delete [] _rawStation;
  delete [] _filterStation;
}

Member Function Documentation

const double& GeopsyCore::WindowingParameters::badSampleThreshold ( ) const [inline]

Referenced by GeopsyCore::StationSignals::setKeep(), and GeopsyGui::WindowingParameterWidget::setParameters().

{return _badSampleThresholdValue;}

SampleThreshold GeopsyCore::WindowingParameters::badSampleThresholdType ( ) const [inline]

Referenced by GeopsyGui::WindowingParameterWidget::setParameters().

{return _badSampleThresholdType;}

QString GeopsyCore::WindowingParameters::badSampleThresholdTypeString ( ) const

References AbsoluteSampleThreshold, NoSampleThreshold, and RelativeSampleThreshold.

Referenced by printDebug(), and toString().

{
  switch(_badSampleThresholdType) {
  case NoSampleThreshold:
    break;
  case RelativeSampleThreshold:
    return "RelativeSampleThreshold";
  case AbsoluteSampleThreshold:
    return "AbsoluteSampleThreshold";
  }
  return "NoSampleThreshold";
}

const double& GeopsyCore::WindowingParameters::badSampleTolerance ( ) const [inline]

Referenced by GeopsyCore::TimeRangeList::add(), and GeopsyGui::WindowingParameterWidget::setParameters().

{return _badSampleTolerance;}

void GeopsyCore::WindowingParameters::collectKeywords ( PARAMETERS_COLLECTKEYWORDS_ARGS ) [virtual]

Reimplemented from QGpCoreTools::AbstractParameters.

References GeopsyCore::FilterParameters::collectKeywords(), and TRACE.

Referenced by ArrayCore::ArrayParameters::collectKeywords(), and MonoStation::AbstractToolParameters::collectKeywords().

{
  TRACE;
  keywords.add(prefix+"WINDOW LENGTH TYPE", this, 0);
  keywords.add(prefix+"WINDOW MIN LENGTH", this, 1);
  keywords.add(prefix+"WINDOW MAX LENGTH", this, 2);
  keywords.add(prefix+"BAD SAMPLE TOLERANCE", this, 3);
  keywords.add(prefix+"WINDOW OVERLAP", this, 4);
  keywords.add(prefix+"BAD SAMPLE THRESHOLD TYPE", this, 5);
  keywords.add(prefix+"BAD SAMPLE THRESHOLD VALUE", this, 6);
  keywords.add(prefix+"BAD SAMPLE THRESHOLD", this, 7);         // For compatibility
  keywords.add(prefix+"ANTI-TRIGGERING ON RAW SIGNAL", this, 8);
  keywords.add(prefix+"USED RAW COMPONENTS", this, 9);
  keywords.add(prefix+"RAW STA", this, 10);
  keywords.add(prefix+"RAW LTA", this, 11);
  keywords.add(prefix+"RAW MIN SLTA", this, 12);
  keywords.add(prefix+"RAW MAX SLTA", this, 13);
  keywords.add(prefix+"ANTI-TRIGGERING ON FILTERED SIGNAL", this, 14);
  keywords.add(prefix+"USED FILTERED COMPONENTS", this, 15);
  keywords.add(prefix+"FILTERED STA", this, 16);
  keywords.add(prefix+"FILTERED LTA", this, 17);
  keywords.add(prefix+"FILTERED MIN SLTA", this, 18);
  keywords.add(prefix+"FILTERED MAX SLTA", this, 19);
  _filter.collectKeywords(keywords, prefix);
}

int GeopsyCore::WindowingParameters::componentCount ( ) const [inline]

{return _componentCount;}

const FilterParameters& GeopsyCore::WindowingParameters::filter ( ) const [inline]

Referenced by GeopsyCore::StationSignals::setKeep(), and GeopsyGui::WindowingParameterWidget::setParameters().

{return _filter;}

bool GeopsyCore::WindowingParameters::filterComponent ( int comp ) const [inline]

Referenced by GeopsyCore::StationSignals::setKeep(), and GeopsyGui::WindowingParameterWidget::setParameters().

{return comp<_componentCount ? _filterComponent[comp] : true;}

const ShortLongTermAverage& GeopsyCore::WindowingParameters::filterSignalAntiTrigger ( ) const [inline]

Referenced by GeopsyCore::StationSignals::setKeep(), and GeopsyGui::WindowingParameterWidget::setParameters().

{return _filterSignalAntiTrigger;}

bool GeopsyCore::WindowingParameters::filterStation ( int stat ) const [inline]

Referenced by GeopsyCore::StationSignals::setKeep(), and GeopsyGui::WindowingParameterWidget::setParameters().

{return stat<_stationCount ? _filterStation[stat] : true;}

bool GeopsyCore::WindowingParameters::isValid ( )

References TRACE.

{
  TRACE;
  if(_periodCount<=0) return false;
  if(_minimumLength<=0) return false;
  if(_maximumLength<=0) return false;
  return true;
}

int GeopsyCore::WindowingParameters::keywordCount ( PARAMETERS_KEYWORDCOUNT_ARGS ) [virtual]

Reimplemented from QGpCoreTools::AbstractParameters.

{
  return 20;
}

LengthType GeopsyCore::WindowingParameters::lengthType ( ) const [inline]

Referenced by GeopsyGui::WindowingParameterWidget::setParameters().

{return _lengthType;}

QString GeopsyCore::WindowingParameters::lengthTypeString ( ) const

References AtLeast, Exactly, FrequencyDependent, and TRACE.

Referenced by printDebug(), and toString().

{
  TRACE;
  switch(_lengthType) {
  case Exactly:
    break;
  case AtLeast:
    return "AtLeast";
  case FrequencyDependent:
    return "FrequencyDependent";
  }
  return "Exactly";
}

double GeopsyCore::WindowingParameters::maximumLength ( double frequency ) const

References FrequencyDependent.

Referenced by GeopsyCore::TimeRangeList::add(), ArrayCore::ArrayProcess::setFrequency(), and GeopsyGui::WindowingParameterWidget::setParameters().

{
  if(_lengthType==FrequencyDependent) {
    if(frequency <= 0.0) frequency=1.0;
    return _periodCount/frequency;
  } else {
    return _maximumLength;
  }
}

double GeopsyCore::WindowingParameters::minimumLength ( double frequency ) const

References FrequencyDependent.

Referenced by GeopsyCore::TimeRangeList::add(), ArrayCore::ArrayProcess::setFrequency(), and GeopsyGui::WindowingParameterWidget::setParameters().

{
  if(_lengthType==FrequencyDependent) {
    if(frequency <= 0.0) frequency=1.0;
    return _periodCount/frequency;
  } else {
    return _minimumLength;
  }
}

void GeopsyCore::WindowingParameters::operator= ( const WindowingParameters & o )

References setComponentCount(), setStationCount(), and TRACE.

{
  TRACE;
  setComponentCount(o._componentCount);
  memcpy(_rawComponent, o._rawComponent, _componentCount * sizeof(bool));
  memcpy(_filterComponent, o._filterComponent, _componentCount * sizeof(bool));

  setStationCount(o._stationCount);
  memcpy(_rawStation, o._rawStation, _stationCount * sizeof(bool));
  memcpy(_filterStation, o._filterStation, _stationCount * sizeof(bool));

  _overlap=o._overlap;
  _badSampleThresholdType=o._badSampleThresholdType;
  _badSampleThresholdValue=o._badSampleThresholdValue;
  _badSampleTolerance=o._badSampleTolerance;
  memcpy(&_rawSignalAntiTrigger, &o._rawSignalAntiTrigger, sizeof(ShortLongTermAverage));
  memcpy(&_filterSignalAntiTrigger, &o._filterSignalAntiTrigger, sizeof(ShortLongTermAverage));
  _filter=o._filter;

  _lengthType=o._lengthType;
  _minimumLength=o._minimumLength;
  _maximumLength=o._maximumLength;
  _periodCount=o._periodCount;
}

const double& GeopsyCore::WindowingParameters::overlap ( ) const [inline]

Referenced by GeopsyCore::TimeRangeList::add(), GeopsyCore::TimeRangeList::addBlanks(), GeopsyCore::TimeRangeList::inverse(), and GeopsyGui::WindowingParameterWidget::setParameters().

{return _overlap;}

double GeopsyCore::WindowingParameters::periodCount ( ) const [inline]

Referenced by GeopsyGui::WindowingParameterWidget::setParameters(), and RealTimeArrayManager::start().

{return _periodCount;}

void GeopsyCore::WindowingParameters::printDebug ( )

References badSampleThresholdTypeString(), GeopsyCore::WindowingParameters::ShortLongTermAverage::enabled, lengthTypeString(), GeopsyCore::WindowingParameters::ShortLongTermAverage::longLength, GeopsyCore::WindowingParameters::ShortLongTermAverage::maximumThreshold, GeopsyCore::WindowingParameters::ShortLongTermAverage::minimumThreshold, GeopsyCore::WindowingParameters::ShortLongTermAverage::shortLength, and TRACE.

{
  TRACE;
  printf("Overlap=%lf\n", _overlap);
  printf("BadSampleThresholdType=%s\n", badSampleThresholdTypeString().toAscii().data());
  printf("BadSampleThresholdValue=%lf\n", _badSampleThresholdValue);
  printf("BadSampleTolerance=%lf\n", _badSampleTolerance);
  printf("Raw enabled %s\n", _rawSignalAntiTrigger.enabled ? "true" : "false");
  printf("Raw short term average length=%lf\n", _rawSignalAntiTrigger.shortLength);
  printf("Raw long term average length=%lf\n", _rawSignalAntiTrigger.longLength);
  printf("Raw minimum threshold=%lf\n", _rawSignalAntiTrigger.minimumThreshold);
  printf("Raw maximum threshold=%lf\n", _rawSignalAntiTrigger.maximumThreshold);
  printf("Filtered enabled %s\n", _filterSignalAntiTrigger.enabled ? "true" : "false");
  printf("Filtered short term average length=%lf\n", _filterSignalAntiTrigger.shortLength);
  printf("Filtered long term average length=%lf\n", _filterSignalAntiTrigger.longLength);
  printf("Filtered minimum threshold=%lf\n", _filterSignalAntiTrigger.minimumThreshold);
  printf("Filtered maximum threshold=%lf\n", _filterSignalAntiTrigger.maximumThreshold);
  printf("Component count=%i\n", _componentCount);
  printf("Station count=%i\n", _stationCount);
  printf("Length type %s\n", lengthTypeString().toAscii().data());
  printf("Minimum length=%lf\n", _minimumLength);
  printf("Maximum length=%lf\n", _maximumLength);
  printf("periodNum=%lf\n", _periodCount);
  printf("Selected raw components: ");
  for(int i=0;i < _componentCount; i++) printf("%s, ", _rawComponent[i] ? "true" : "false");
  printf("\nSelected filter components: ");
  for(int i=0;i < _componentCount; i++) printf("%s, ", _filterComponent[i] ? "true" : "false");
  printf("Selected raw: ");
  for(int i=0;i < _stationCount; i++) printf("%s, ", _rawStation[i] ? "true" : "false");
  printf("\nSelected filtered: ");
  for(int i=0;i < _stationCount; i++) printf("%s, ", _filterStation[i] ? "true" : "false");
  printf("\n");
}

bool GeopsyCore::WindowingParameters::rawComponent ( int comp ) const [inline]

Referenced by GeopsyCore::StationSignals::setKeep(), and GeopsyGui::WindowingParameterWidget::setParameters().

{return comp<_componentCount ? _rawComponent[comp] : true;}

const ShortLongTermAverage& GeopsyCore::WindowingParameters::rawSignalAntiTrigger ( ) const [inline]

Referenced by GeopsyCore::StationSignals::setKeep(), and GeopsyGui::WindowingParameterWidget::setParameters().

{return _rawSignalAntiTrigger;}

bool GeopsyCore::WindowingParameters::rawStation ( int stat ) const [inline]

Referenced by GeopsyCore::StationSignals::setKeep(), and GeopsyGui::WindowingParameterWidget::setParameters().

{return stat<_stationCount ? _rawStation[stat] : true;}

void GeopsyCore::WindowingParameters::setBadSampleThreshold ( const double & b ) [inline]

Referenced by GeopsyGui::WindowingParameterWidget::getParameters().

{_badSampleThresholdValue=b;}

void GeopsyCore::WindowingParameters::setBadSampleThresholdType ( SampleThreshold t ) [inline]

Referenced by setValue().

{_badSampleThresholdType=t;}

void GeopsyCore::WindowingParameters::setBadSampleThresholdType ( const QString & t )

References AbsoluteSampleThreshold, QGpCoreTools::endl(), NoSampleThreshold, RelativeSampleThreshold, and QGpCoreTools::tr().

{
  if(!t.isEmpty()) {
    QString lt=t.toLower();
    switch(lt[0].unicode()) {
    case 'a':
      if(lt=="absolutesamplethreshold") {
        _badSampleThresholdType=AbsoluteSampleThreshold;
        return;
      }
      break;
    case 'n':
      if(lt=="nosamplethreshold") {
        _badSampleThresholdType=NoSampleThreshold;
        return;
      }
      break;
    case 'r':
      if(lt=="relativesamplethreshold") {
        _badSampleThresholdType=RelativeSampleThreshold;
        return;
      }
      break;
    default:
      break;
    }
    App::stream() << tr("Unrecognized bad sample threshold type: %1").arg(t) << endl;
  }
}

void GeopsyCore::WindowingParameters::setBadSampleTolerance ( const double & b ) [inline]

Referenced by GeopsyGui::WindowingParameterWidget::getParameters().

{_badSampleTolerance=b;}

void GeopsyCore::WindowingParameters::setComponentCount ( int n )

Referenced by GeopsyGui::WindowingParameterWidget::getParameters(), operator=(), and setValue().

{
  _componentCount=n;
  delete [] _rawComponent;
  _rawComponent=new bool[_componentCount];
  for(int i=0; i< _componentCount; i++) _rawComponent[i]=false;
  delete [] _filterComponent;
  _filterComponent=new bool[_componentCount];
  for(int i=0; i<_componentCount; i++) _filterComponent[i]=false;
}

void GeopsyCore::WindowingParameters::setFilter ( const FilterParameters & f ) [inline]

Referenced by GeopsyGui::WindowingParameterWidget::getParameters().

{_filter=f;}

void GeopsyCore::WindowingParameters::setFilterComponent	(	int	comp,
		bool	b
	)		`[inline]`

Referenced by GeopsyGui::WindowingParameterWidget::getParameters().

{ASSERT(comp<_componentCount); _filterComponent[comp]=b;}

void GeopsyCore::WindowingParameters::setFilterSignalAntiTrigger ( const ShortLongTermAverage & f ) [inline]

Referenced by GeopsyGui::WindowingParameterWidget::getParameters().

{_filterSignalAntiTrigger=f;}

void GeopsyCore::WindowingParameters::setFilterStation	(	int	stat,
		bool	b
	)		`[inline]`

Referenced by GeopsyGui::WindowingParameterWidget::getParameters().

{ASSERT(stat<_stationCount); _filterStation[stat]=b;}

void GeopsyCore::WindowingParameters::setLength	(	double	tmin,
		double	tmax
	)

References AtLeast, and TRACE.

Referenced by GeopsyGui::WindowingParameterWidget::getParameters().

{
  TRACE;
  _lengthType=AtLeast;
  if(min<max) {
    _minimumLength=min;
    _maximumLength=max;
  } else {
    _maximumLength=min;
    _minimumLength=max;
  }
}

void GeopsyCore::WindowingParameters::setLength ( double t )

References Exactly, and TRACE.

{
  TRACE;
  _lengthType=Exactly;
  _minimumLength=l;
  _maximumLength=l;
}

void GeopsyCore::WindowingParameters::setLengthType ( const QString & l )

References AtLeast, QGpCoreTools::endl(), Exactly, FrequencyDependent, QGpCoreTools::tr(), and TRACE.

Referenced by setValue().

{
  TRACE;
  if(!l.isEmpty()) {
    QString ll=l.toLower();
    switch(ll[0].unicode()) {
    case 'a':
      if(ll=="atleast" ||
         ll=="at least") { // Compatibility
        _lengthType=AtLeast;
        return;
      }
      break;
    case 'e':
      if(ll=="exactly") {
        _lengthType=Exactly;
        return;
      }
      break;
    case 'f':
      if(ll=="frequencydependent" ||
         ll=="freq. dep.") {  // Compatibility
        _lengthType=FrequencyDependent;
        return;
      }
      break;
    default:
      break;
    }
    App::stream() << tr("Unrecognized length type: %1").arg(l) << endl;
  }
}

void GeopsyCore::WindowingParameters::setOverlap ( const double & o ) [inline]

Referenced by GeopsyGui::WindowingParameterWidget::getParameters().

{_overlap=o;}

void GeopsyCore::WindowingParameters::setPeriodCount ( double n )

References FrequencyDependent, and TRACE.

Referenced by GeopsyGui::WindowingParameterWidget::getParameters(), and RealTimeArrayManager::setWindowLenght().

{
  TRACE;
  _lengthType=FrequencyDependent;
  _periodCount=n;
  _minimumLength=n; // To avoid warning for null time windows in pre-processings
  _maximumLength=n;
}

void GeopsyCore::WindowingParameters::setRawComponent	(	int	comp,
		bool	b
	)		`[inline]`

Referenced by GeopsyGui::WindowingParameterWidget::getParameters().

{ASSERT(comp<_componentCount); _rawComponent[comp]=b;}

void GeopsyCore::WindowingParameters::setRawSignalAntiTrigger ( const ShortLongTermAverage & r ) [inline]

Referenced by GeopsyGui::WindowingParameterWidget::getParameters().

{_rawSignalAntiTrigger=r;}

void GeopsyCore::WindowingParameters::setRawStation	(	int	stat,
		bool	b
	)		`[inline]`

Referenced by GeopsyGui::WindowingParameterWidget::getParameters().

{ASSERT(stat<_stationCount); _rawStation[stat]=b;}

void GeopsyCore::WindowingParameters::setStationCount ( int n )

Referenced by GeopsyGui::WindowingParameterWidget::getParameters(), and operator=().

{
  _stationCount=n;
  delete [] _rawStation;
  _rawStation=new bool[_stationCount];
  for(int i=0; i<_stationCount; i++) _rawStation[i]=false;
  delete [] _filterStation;
  _filterStation=new bool[_stationCount];
  for(int i=0; i<_stationCount; i++) _filterStation[i]=false;
}

bool GeopsyCore::WindowingParameters::setValue ( PARAMETERS_SETVALUE_ARGS ) [virtual]

Reimplemented from QGpCoreTools::AbstractParameters.

References QGpCoreTools::LineParser::count(), GeopsyCore::WindowingParameters::ShortLongTermAverage::enabled, GeopsyCore::WindowingParameters::ShortLongTermAverage::longLength, GeopsyCore::WindowingParameters::ShortLongTermAverage::maximumThreshold, GeopsyCore::WindowingParameters::ShortLongTermAverage::minimumThreshold, RelativeSampleThreshold, setBadSampleThresholdType(), setComponentCount(), QGpCoreTools::LineParser::setDelimiters(), setLengthType(), GeopsyCore::WindowingParameters::ShortLongTermAverage::shortLength, QGpCoreTools::LineParser::toString(), and TRACE.

{
  TRACE;
  switch(index) {
  case 0:
    setLengthType(value);
    return true;
  case 1:
    _minimumLength=value.toDouble();
    return true;
  case 2:
    _maximumLength=value.toDouble();
    return true;
  case 3:
    _badSampleTolerance=value.toDouble();
    return true;
  case 4:
    _overlap=value.toDouble();
    return true;
  case 5:
    setBadSampleThresholdType(value);
    return true;
  case 6:
    _badSampleThresholdValue=value.toDouble();
    return true;
  case 7:                                           // For compatibility
    _badSampleThresholdValue=value.toDouble();
    _badSampleThresholdType=RelativeSampleThreshold;
    return true;
  case 8:
    _rawSignalAntiTrigger.enabled=(value=="y");
    return true;
  case 9: {
    LineParser p(value);
      p.setDelimiters(",");
      if(_componentCount==0) {
        setComponentCount(p.count());
      }
      bool ok=true;
      for(int i=0; i<_componentCount; i++) {
        _rawComponent[i]=(p.toString(i, ok)=="y" && ok);
      }
    }
    return true;
  case 10:
    _rawSignalAntiTrigger.shortLength=value.toDouble();
    return true;
  case 11:
    _rawSignalAntiTrigger.longLength=value.toDouble();
    return true;
  case 12:
    _rawSignalAntiTrigger.minimumThreshold=value.toDouble();
    return true;
  case 13:
    _rawSignalAntiTrigger.maximumThreshold=value.toDouble();
    return true;
  case 14:
    _rawSignalAntiTrigger.enabled=(value=="y");
    return true;
  case 15: {
      LineParser p(value);
      p.setDelimiters(",");
      if(_componentCount==0) {
        setComponentCount(p.count());
      }
      bool ok=true;
      for(int i=0; i<_componentCount; i++) {
        _filterComponent[i]=(p.toString(i, ok)=="y" && ok);
      }
    }
    return true;
  case 16:
    _filterSignalAntiTrigger.shortLength=value.toDouble();
    return true;
  case 17:
    _filterSignalAntiTrigger.longLength=value.toDouble();
    return true;
  case 18:
    _filterSignalAntiTrigger.minimumThreshold=value.toDouble();
    return true;
  case 19:
    _filterSignalAntiTrigger.maximumThreshold=value.toDouble();
    return true;
  default:
    return false;
  }
}

int GeopsyCore::WindowingParameters::stationCount ( ) const [inline]

{return _stationCount;}

QString GeopsyCore::WindowingParameters::toString ( PARAMETERS_TOSTRING_ARGS_DECL ) const [virtual]

Reimplemented from QGpCoreTools::AbstractParameters.

References badSampleThresholdTypeString(), GeopsyCore::WindowingParameters::ShortLongTermAverage::enabled, lengthTypeString(), QGpCoreTools::log(), GeopsyCore::WindowingParameters::ShortLongTermAverage::longLength, GeopsyCore::WindowingParameters::ShortLongTermAverage::maximumThreshold, GeopsyCore::WindowingParameters::ShortLongTermAverage::minimumThreshold, GeopsyCore::WindowingParameters::ShortLongTermAverage::shortLength, GeopsyCore::FilterParameters::toString(), and TRACE.

Referenced by ArrayCore::ArrayParameters::toString(), and MonoStation::AbstractToolParameters::toString().

{
  TRACE;
  QString log;
  log+="WINDOW LENGTH TYPE="+lengthTypeString()+"\n";
  log+="WINDOW MIN LENGTH="+QString::number(_minimumLength)+"\n";
  log+="WINDOW MAX LENGTH="+QString::number(_maximumLength)+"\n";
  log+="IS BAD SAMPLE TOLERANCE=";
  log+=(_badSampleTolerance>0.0) ? "y\n" : "n\n";
  log+="BAD SAMPLE TOLERANCE="+QString::number(_badSampleTolerance)+"\n";
  log+="IS WINDOW OVERLAP=";
  log+=(_overlap>0.0) ? "y\n" : "n\n";
  log+="WINDOW OVERLAP="+QString::number(_overlap)+"\n";
  log+="BAD SAMPLE THRESHOLD TYPE="+badSampleThresholdTypeString()+"\n";
  log+="BAD SAMPLE THRESHOLD="+QString::number(_badSampleThresholdValue)+"\n";
  log+="ANTI-TRIGGERING ON RAW SIGNAL (y/n)=";
  log+=_rawSignalAntiTrigger.enabled ? "y\n" : "n\n";
  log+="USED RAW COMPONENTS=";
  log+=_rawComponent[0] ? "y" : "n";
  for(int i=1; i<_componentCount; i++) {
    log+=_rawComponent[i] ? ", y" : ", n";
  }
  log+="\n";
  log+="RAW STA (s)="+QString::number(_rawSignalAntiTrigger.shortLength)+"\n";
  log+="RAW LTA (s)="+QString::number(_rawSignalAntiTrigger.longLength)+"\n";
  log+="RAW MIN SLTA="+QString::number(_rawSignalAntiTrigger.minimumThreshold)+"\n";
  log+="RAW MAX SLTA="+QString::number(_rawSignalAntiTrigger.maximumThreshold)+"\n";
  log+="ANTI-TRIGGERING ON FILTERED SIGNAL (y/n)=";
  log+=_filterSignalAntiTrigger.enabled ? "y\n" : "n\n";
  if(_filterSignalAntiTrigger.enabled) {
    log+=_filter.toString(prefix);
    log+="USED FILTERED COMPONENTS=";
    log+=_filterComponent[0] ? "y" : "n";
    for(int i=1; i<_componentCount; i++) {
      log+=_filterComponent[i] ? ", y" : ", n";
    }
    log+="\n";
    log+="FILTERED STA (s)="+QString::number(_filterSignalAntiTrigger.shortLength)+"\n";
    log+="FILTERED LTA (s)="+QString::number(_filterSignalAntiTrigger.longLength)+"\n";
    log+="FILTERED MIN SLTA="+QString::number(_filterSignalAntiTrigger.minimumThreshold)+"\n";
    log+="FILTERED MAX SLTA="+QString::number(_filterSignalAntiTrigger.maximumThreshold)+"\n";
  }
  return log;
}

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

GeopsyCore/WindowingParameters.h
GeopsyCore/WindowingParameters.cpp

Classes

Public Types

Public Member Functions

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation