Calculate Rayleigh ellipticity curves and their misfits. More...

#include <CompatModalEllipticity.h>

Inheritance diagram for QGpCompatibility::CompatModalEllipticity:

Public Member Functions
	CompatModalEllipticity ()
CompatVDataPoint &	f0 ()
double	frequencyMisfit (CompatModalDispersion &disp, Rayleigh &model)
double	misfit ()
double	misfit (int iMin, int iMax)
CompatEllipticityData *	oldStyle ()
void	operator= (CompatModalEllipticity &o)
bool	peakFrequencyMisfit ()
virtual void	setNModes (int nm)
void	setPeakFrequencyMisfit (bool pfm)
Protected Member Functions
virtual XMLMember	xml_member (XML_MEMBER_ARGS)
bool	xml_setProperty (XML_SETPROPERTY_ARGS)
virtual const QString &	xml_tagName () const
virtual void	xml_writeChildren (XML_WRITECHILDREN_ARGS) const
virtual void	xml_writeProperties (XML_WRITEPROPERTIES_ARGS) const
Static Protected Attributes
static const QString	xmlModalEllipticityTag = "ModalEllipticity"

Detailed Description

Calculate Rayleigh ellipticity curves and their misfits.

The main function used to calculate the ellipticity curve is calculate().

Misfits can be computed by misfit() or closestModeMisfit().

Constructor & Destructor Documentation

QGpCompatibility::CompatModalEllipticity::CompatModalEllipticity ( ) [inline]

References COMPATMODALELLIPTICITY_INVALID_VALUE.

{_curves.setInvalidValue(COMPATMODALELLIPTICITY_INVALID_VALUE);}

Member Function Documentation

CompatVDataPoint& QGpCompatibility::CompatModalEllipticity::f0 ( ) [inline]

{return _f0;}

double QGpCompatibility::CompatModalEllipticity::frequencyMisfit	(	CompatModalDispersion &	disp,
		Rayleigh &	model
	)

double QGpCompatibility::CompatModalEllipticity::misfit ( ) [inline]

References misfit().

Referenced by misfit().

{return misfit(0,nOmegas()-1);}

double QGpCompatibility::CompatModalEllipticity::misfit	(	int	iMin,
		int	iMax
	)

Calculate the misfit for the current calculated ellipticity curve between frequency indexes iMin and iMax.

References COMPATMODALELLIPTICITY_INVALID_VALUE, QGpCoreTools::endl(), QGpCompatibility::CompatModalRefinedCurves::mode(), QGpCoreTools::sqrt(), QGpCoreTools::tr(), and TRACE.

{
  TRACE;
  // Global RMS is the sum of the RMS of all modes
  double rms_val=0;
  int omegaCountReal=iMax-iMin+1;
  int omegaCountData=omegaCountReal;
  CompatVDataPointVector point=mode(0);
  for(int i=iMin;i<=iMax;i++)
    rms_val+=point[i].misfitOrder2(omegaCountData, omegaCountReal, COMPATMODALELLIPTICITY_INVALID_VALUE);
  if(omegaCountReal>0)
    rms_val=sqrt(rms_val/omegaCountReal)*(1+omegaCountData-omegaCountReal);
  else if(omegaCountData==0) rms_val=0;
  else {
    App::stream() << tr(" *** ERROR *** : no common value between calculated and data, this should never happen!") << endl;
    rms_val=10000; 
  }
  return rms_val;
}

CompatEllipticityData * QGpCompatibility::CompatModalEllipticity::oldStyle ( )

References QGpCompatibility::CompatModalRefinedCurves::mode(), QGpCompatibility::CompatModalRefinedCurves::nModes(), QGpCompatibility::CompatModalFrequency::nOmegas(), QGpCompatibility::CompatModalFrequency::omega(), QGpCompatibility::CompatMultiModalFrequency::setFrequency(), QGpCompatibility::CompatMultiModalData::setMean(), QGpCompatibility::CompatMultiModalData::setStddev(), QGpCompatibility::CompatMultiModalCurves::setValue(), QGpCompatibility::CompatMultiModalData::setWeight(), and TRACE.

{
  TRACE;
  int nm=nModes();
  int nf=nOmegas();
  CompatEllipticityData * ell=new CompatEllipticityData(nm,nf);
  for(int i=0;i<nf;i++) {
    ell->setFrequency(i,omega(i)/(2*M_PI));
  }
  for(int im=0;im<nm;im++) {
    CompatVDataPointVector point=mode(im);
    for(int i=0;i<nf;i++) {
      ell->setMean(i,im,point[i].mean());
      ell->setStddev(i,im,point[i].stddev());
      ell->setWeight(i,im,point[i].weight());
      ell->setValue(i,im,point[i].value());
    }
  }
  return ell;
}

void QGpCompatibility::CompatModalEllipticity::operator= ( CompatModalEllipticity & o )

References TRACE.

{
  TRACE;
  CompatModalRefinedCurves::operator=(o);
  _peakFrequencyMisfit=o._peakFrequencyMisfit;
  _f0=o._f0;
}

bool QGpCompatibility::CompatModalEllipticity::peakFrequencyMisfit ( ) [inline]

{return _peakFrequencyMisfit;}

virtual void QGpCompatibility::CompatModalEllipticity::setNModes ( int nm ) [inline, virtual]

Reimplemented from QGpCompatibility::CompatModalRefinedCurves.

References QGpCompatibility::CompatModalRefinedCurves::setNModes().

                                 {
    CompatModalRefinedCurves::setNModes(nm);
    setNRayleighModes(nm);
  }

void QGpCompatibility::CompatModalEllipticity::setPeakFrequencyMisfit ( bool pfm ) [inline]

{_peakFrequencyMisfit=pfm;}

XMLMember QGpCompatibility::CompatModalEllipticity::xml_member ( XML_MEMBER_ARGS ) [protected, virtual]

Re-implement this function to offer XML restore (children and properties) support to your class.

From tag and map (with contains the attibute value) return a unique identifier under the format of a XMLMember. XMLMember is initialized with 3 types of contructors:

An integer: id number of a property
A XMLClass * : a child of this object identified by tag
Default constructor: error, unknow child or property

Map of attributes can be inspected in this way (can be achived also in xml_setProperty()):

    static const QString tmp("childrenName");
    XMLRestoreAttributeIterator it=map.find(tmp);
    if(it!=map.end()) {
      // found attribute "childrenName"
    }

If the map of attributes is not used:

    Q_UNUSED(attributes);
    if(tag=="x1") return XMLMember(0);
    else if(tag=="y1") return XMLMember(1);
    else if(tag=="x2") return XMLMember(2);
    else if(tag=="y2") return XMLMember(3);
    else return XMLMember(XMLMember::Unknown);

Arithmetic operations + and - apply to XMLMember to avoid confusion of property id numbers between inherited objects. Offset 3 corresponds to the number of properties defined in this object.

    if(tag=="anInteger") return XMLMember(0);
    else if(tag=="aString") return XMLMember(1);
    else if(tag=="aDouble") return XMLMember(2);
    return AbstractLine::xml_member(tag, attributes, context)+3;

For the arguments of this function use Macro XML_MEMBER_ARGS.

Reimplemented from QGpCompatibility::CompatModalRefinedCurves.

References TRACE.

{
  TRACE;
  if(tag=="DataPoint") return XMLMember(&_f0);
  else if(tag=="peakFrequencyMisfit") return XMLMember(0);
  return CompatModalRefinedCurves::xml_member(tag, attributes, context)+1;
}

bool QGpCompatibility::CompatModalEllipticity::xml_setProperty ( XML_SETPROPERTY_ARGS ) [protected, virtual]

Re-implement this function to offer XML restore properties support to your class.

From memberID set the corresponding property with value content. The map of attributes is given as a supplementary information (not useful in all cases).

For a general case:

  Q_UNUSED(attributes);
  double val=content.toDouble();
  switch (memberID) {
  case 0:
    _x1=val;
    return true;
  case 1:
    _y1=val;
    return true;
  case 2:
    _x2=val;
    return true;
  case 3:
    _y2=val;
    return true;
  default:
    return false;
  }

For classes inheriting other classes (see also xml_member())

  switch (memberID) {
  case 0:
    _anInteger=content.toString();
    return true;
  case 1:
    _aString=content.toInt();
    return true;
  case 2:
    _aDouble=content.toDouble();
    return true;
  default:
    return AbstractLine::xml_setProperty(memberID-3, map, content);

For the arguments of this function use Macro XML_SETPROPERTY_ARGS.

Reimplemented from QGpCompatibility::CompatModalFrequency.

References TRACE.

{
  TRACE;
  if(memberID==0) {
    _peakFrequencyMisfit=content.toBool();
    return true;
  } else return CompatModalRefinedCurves::xml_setProperty(memberID-1, tag, attributes, content, context);
}

virtual const QString& QGpCompatibility::CompatModalEllipticity::xml_tagName ( ) const [inline, protected, virtual]

Reimplemented from QGpCompatibility::CompatModalRefinedCurves.

{return xmlModalEllipticityTag;}

void QGpCompatibility::CompatModalEllipticity::xml_writeChildren ( XML_WRITECHILDREN_ARGS ) const [protected, virtual]

Reimplemented from QGpCompatibility::CompatModalRefinedCurves.

References TRACE, and QGpCoreTools::XMLClass::xml_save().

{
  TRACE;
  _f0.xml_save(s, context);
  CompatModalRefinedCurves::xml_writeChildren(s, context);
}

void QGpCompatibility::CompatModalEllipticity::xml_writeProperties ( XML_WRITEPROPERTIES_ARGS ) const [protected, virtual]

Reimplemented from QGpCompatibility::CompatModalFrequency.

References TRACE, and QGpCoreTools::XMLClass::writeProperty().

{
  TRACE;
  writeProperty(s, "peakFrequencyMisfit",_peakFrequencyMisfit);
  CompatModalRefinedCurves::xml_writeProperties(s, context);
}

Member Data Documentation

const QString QGpCompatibility::CompatModalEllipticity::xmlModalEllipticityTag = "ModalEllipticity" [static, protected]

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

QGpCompatibility/CompatModalEllipticity.h
QGpCompatibility/CompatModalEllipticity.cpp

Public Member Functions

Protected Member Functions

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation