#include <CompatModalRefinedCurves.h>

Inheritance diagram for QGpCompatibility::CompatModalRefinedCurves:

Public Member Functions
void	addInvalidSamples (CompatModalFrequency *samples)
virtual void	addRayleighModes (int nNewModes)
void	clearRefines ()
QVector< double > *	meanVector (int im)
CompatVDataPointVector &	mode (int im)
const CompatVDataPointVector &	mode (int im) const
int	nModes () const
int	nRefines () const
void	operator= (CompatModalRefinedCurves &o)
void	refineSort ()
virtual void	setNModes (int nm)
void	setNOmegas (int nf)
QVector< double > *	stddevVector (int im)
int	toPointVector (int imode, Point2D *&pointList)
QVector< Point > *	toPointVector (int imode)
void	toStream (FILE *f)
QVector< double > *	weightVector (int im)
void	writeReport (QDataStream &s) const
Protected Member Functions
virtual void	addInvalid ()
virtual void	insertInvalidAt (int i)
virtual XMLMember	xml_member (XML_MEMBER_ARGS)
virtual const QString &	xml_tagName () const
virtual void	xml_writeChildren (XML_WRITECHILDREN_ARGS) const
Protected Attributes
CompatModalCurves	_curves
CompatRefineList	_refines
Static Protected Attributes
static const QString	xmlModalRefinedCurvesTag = "ModalRefinedCurves"

Member Function Documentation

virtual void QGpCompatibility::CompatModalRefinedCurves::addInvalid ( ) [inline, protected, virtual]

Implements QGpCompatibility::CompatModalFrequency.

{_curves.addInvalid();}

void QGpCompatibility::CompatModalRefinedCurves::addInvalidSamples ( CompatModalFrequency * samples )

void QGpCompatibility::CompatModalRefinedCurves::addRayleighModes ( int nNewModes ) [virtual]

if there are Love modes, the task is a bit more complex...

Implements QGpCompatibility::CompatModalFrequency.

References _curves, QGpCompatibility::CompatModalCurves::insertModes(), QGpCompatibility::CompatModalFrequency::nRayleighModes(), QGpCompatibility::CompatModalFrequency::setNRayleighModes(), and TRACE.

{
  TRACE;
  _curves.insertModes(nRayleighModes(), nNewModes);
  setNRayleighModes(nRayleighModes()+nNewModes);
}

void QGpCompatibility::CompatModalRefinedCurves::clearRefines ( ) [inline]

{_refines.clear();}

virtual void QGpCompatibility::CompatModalRefinedCurves::insertInvalidAt ( int i ) [inline, protected, virtual]

Implements QGpCompatibility::CompatModalFrequency.

{_curves.insertInvalidAt(i);}

QVector<double>* QGpCompatibility::CompatModalRefinedCurves::meanVector ( int im ) [inline]

{return _curves.meanVector(im);}

CompatVDataPointVector& QGpCompatibility::CompatModalRefinedCurves::mode ( int im ) [inline]

Referenced by QGpCompatibility::CompatModalEllipticity::misfit(), QGpCompatibility::CompatModalEllipticity::oldStyle(), QGpCompatibility::CompatModalDispersion::oldStyle(), toPointVector(), toStream(), writeReport(), and DinverDCCore::TargetList::xml_polishChild().

{return _curves.mode(im);}

const CompatVDataPointVector& QGpCompatibility::CompatModalRefinedCurves::mode ( int im ) const [inline]

{return _curves.mode(im);}

int QGpCompatibility::CompatModalRefinedCurves::nModes ( ) const [inline, virtual]

Implements QGpCompatibility::CompatModalFrequency.

Referenced by QGpCompatibility::CompatModalEllipticity::oldStyle(), QGpCompatibility::CompatModalDispersion::oldStyle(), toPointVector(), toStream(), writeReport(), and DinverDCCore::TargetList::xml_polishChild().

{return _curves.nModes();}

int QGpCompatibility::CompatModalRefinedCurves::nRefines ( ) const [inline]

{return _refines.size();}

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

References _curves, and TRACE.

{
  TRACE;
  CompatModalFrequency::operator=(o);
  _curves=o._curves;
}

void QGpCompatibility::CompatModalRefinedCurves::refineSort ( ) [inline]

{qSort(_refines);}

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

Implements QGpCompatibility::CompatModalFrequency.

Reimplemented in QGpCompatibility::CompatModalEllipticity.

Referenced by QGpCompatibility::CompatModalEllipticity::setNModes().

{_curves.setNModes(nm);}

void QGpCompatibility::CompatModalRefinedCurves::setNOmegas ( int nf ) [inline, virtual]

Reimplemented from QGpCompatibility::CompatModalFrequency.

References _curves, QGpCompatibility::CompatModalCurves::setNOmegas(), and TRACE.

{
  TRACE;
  CompatModalFrequency::setNOmegas(nf);
  _curves.setNOmegas(nf);
}

QVector<double>* QGpCompatibility::CompatModalRefinedCurves::stddevVector ( int im ) [inline]

{return _curves.stddevVector(im);}

int QGpCompatibility::CompatModalRefinedCurves::toPointVector	(	int	imode,
		Point2D *&	pointList
	)

References _curves, _refines, inv2pi, QGpCompatibility::CompatModalCurves::invalidValue(), mode(), nModes(), QGpCompatibility::CompatModalFrequency::nOmegas(), QGpCompatibility::CompatModalFrequency::omega(), and TRACE.

{
  TRACE;
  int nm=nModes();
  int nf=nOmegas();
  int count=nf;
  ASSERT(imode<nm);
  // init fixed values
  double nextFixedX=omega(0);
  CompatVDataPointVector& point=mode(imode);
  // init refines values
  CompatRefineIterator it=_refines.begin();
  double nextRefineX;
  // Currently refines are for Rayleigh fundamental mode only
  if(imode==0 && it!=_refines.end()) {
    nextRefineX=(*it).omega();
  } else {
    nextRefineX=1e99;
    it=_refines.end();
  }
  // loop variables
  double val, invalidValue=_curves.invalidValue();
  int i=0;
  while(i<nf || it!=_refines.end()) {
    while(nextFixedX<nextRefineX) {
      val=point[i].value();
      if(val!=invalidValue)
        *(pointList++)=Point2D(inv2pi*nextFixedX,val);
      else count--;
      i++;
      if(i<nf) nextFixedX=omega(i);
      else {
        nextFixedX=1e99;
        break;
      }
    }
    while(nextRefineX<nextFixedX) {
      val=(*it).value(imode);
      if(val!=invalidValue) {
        *(pointList++)=Point2D(inv2pi*nextRefineX,val);
        count++;
      }
      ++it;
      if(it!=_refines.end())
        nextRefineX=(*it).omega();
      else {
        nextRefineX=1e99;
        break;
      }
    }
  }
  return count;
}

QVector< Point > * QGpCompatibility::CompatModalRefinedCurves::toPointVector ( int imode )

References _curves, _refines, inv2pi, QGpCompatibility::CompatModalCurves::invalidValue(), mode(), nModes(), QGpCompatibility::CompatModalFrequency::nOmegas(), and QGpCompatibility::CompatModalFrequency::omega().

{
  int nm=nModes();
  int nf=nOmegas();
  ASSERT(imode<nm);
  QVector<Point> * points=new QVector<Point>;
  // init fixed values
  double nextFixedX=omega(0);
  CompatVDataPointVector& point=mode(imode);
  // init refines values
  CompatRefineIterator it=_refines.begin();
  double nextRefineX;
  // Currently refines are for Rayleigh fundamental mode only
  if(imode==0 && it!=_refines.end()) {
    nextRefineX=(*it).omega();
  } else {
    nextRefineX=1e99;
    it=_refines.end();
  }
  // loop variables
  double val, invalidValue=_curves.invalidValue();
  int i=0;
  while(i<nf || it!=_refines.end()) {
    while(nextFixedX<nextRefineX) {
      val=point[i].value();
      if(val!=invalidValue) points->append(Point(inv2pi*nextFixedX,val,0));
      i++;
      if(i<nf) nextFixedX=omega(i);
      else {
        nextFixedX=1e99;
        break;
      }
    }
    while(nextRefineX<nextFixedX) {
      val=(*it).value(imode);
      if(val!=invalidValue) points->append(Point(inv2pi*nextRefineX,val,0));
      ++it;
      if(it!=_refines.end())
        nextRefineX=(*it).omega();
      else {
        nextRefineX=1e99;
        break;
      }
    }
  }
  return points;
}

void QGpCompatibility::CompatModalRefinedCurves::toStream ( FILE * f )

References _curves, _refines, inv2pi, QGpCompatibility::CompatModalCurves::invalidValue(), mode(), nModes(), QGpCompatibility::CompatModalFrequency::nOmegas(), QGpCompatibility::CompatModalFrequency::omega(), and TRACE.

{
  TRACE;
  int nm=nModes();
  int nf=nOmegas();
  for(int imode=0; imode<nm;imode++) {
    // init fixed values
    double nextFixedX=omega(0);
    CompatVDataPointVector& point=mode(imode);
    // init refines values
    CompatRefineIterator it=_refines.begin();
    double nextRefineX;
    // Currently refines are for Rayleigh fundamental mode only
    if(imode==0 && it!=_refines.end()) {
      nextRefineX=(*it).omega();
    } else {
      nextRefineX=1e99;
      it=_refines.end();
    }
    // loop variables
    double val, invalidValue=_curves.invalidValue();
    int i=0;
    while(i<nf || it!=_refines.end()) {
      while(nextFixedX<nextRefineX) {
        val=point[i].value();
        if(val!=invalidValue) fprintf(f,"%lg %lg\n",inv2pi*nextFixedX,val);
        i++;
        if(i<nf) nextFixedX=omega(i);
        else {
          nextFixedX=1e99;
          break;
        }
      }
      while(nextRefineX<nextFixedX) {
        val=(*it).value(imode);
        if(val!=invalidValue) fprintf(f,"%lg %lg\n",inv2pi*nextRefineX,val);
        ++it;
        if(it!=_refines.end())
          nextRefineX=(*it).omega();
        else {
          nextRefineX=1e99;
          break;
        }
      }
    }
  }
}

QVector<double>* QGpCompatibility::CompatModalRefinedCurves::weightVector ( int im ) [inline]

{return _curves.weightVector(im);}

void QGpCompatibility::CompatModalRefinedCurves::writeReport ( QDataStream & s ) const

Save all to report (including frequency), mixing refines and original samples, removing invalid values

Begin with a table of the number of samples per mode

4 nm Modes 4 n Rayleigh modes nm*4 table of number of samples per mode sum(nfr)*2*8 values: sum(nfr)*2*8

References _curves, _refines, inv2pi, QGpCompatibility::CompatModalCurves::invalidValue(), mode(), nModes(), QGpCompatibility::CompatModalFrequency::nOmegas(), QGpCompatibility::CompatModalFrequency::nRayleighModes(), QGpCompatibility::CompatModalFrequency::omega(), and TRACE.

{
  TRACE;
  int nm=nModes();
  int nf=nOmegas();
  s << nm;
  s << nRayleighModes();
  int nfr=0;
  for(int imode=0; imode<nm;imode++) {
    // room for sample per mode table
    qint64 nSamplesPos=s.device()->pos();
    s << nfr;
    // init fixed values
    double nextFixedX=omega(0);
    const CompatVDataPointVector& point=mode(imode);
    // init refines values
    CompatRefineConstIterator it=_refines.begin();
    double nextRefineX;
    // Currently refines are for Rayleigh fundamental mode only
    if(imode==0 && it!=_refines.end()) {
      nextRefineX=(*it).omega();
    } else {
      nextRefineX=1e99;
      it=_refines.end();
    }
    // loop variables
    double val, invalidValue=_curves.invalidValue();
    int i=0;
    nfr=0; // initialize the real number of frequencies
    while(i<nf || it!=_refines.end()) {
      while(nextFixedX<nextRefineX) {
        val=point[i].value();
        if(val!=invalidValue) {
          s << inv2pi*nextFixedX << val;
          nfr++;
        }
        i++;
        if(i<nf) nextFixedX=omega(i);
        else {
          nextFixedX=1e99;
          break;
        }
      }
      while(nextRefineX<nextFixedX) {
        val=(*it).value(imode);
        if(val!=invalidValue) {
          s << inv2pi*nextRefineX << val;
          nfr++;
        }
        ++it;
        if(it!=_refines.end())
          nextRefineX=(*it).omega();
        else {
          nextRefineX=1e99;
          break;
        }
      }
    }
    // Write the real number of frequencies in the table
    qint64 curPos=s.device()->pos();
    s.device()->seek(nSamplesPos);
    s << nfr;
    s.device()->seek(curPos);
  }
}

XMLMember QGpCompatibility::CompatModalRefinedCurves::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::CompatModalFrequency.

Reimplemented in QGpCompatibility::CompatModalEllipticity.

References _curves, and TRACE.

{
  TRACE;
  if(tag=="ModalCurves") return XMLMember(&_curves);
  else return CompatModalFrequency::xml_member(tag, attributes, context);
}

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

Reimplemented from QGpCompatibility::CompatModalFrequency.

Reimplemented in QGpCompatibility::CompatModalEllipticity, and QGpCompatibility::CompatModalDispersion.

{return xmlModalRefinedCurvesTag;}

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

Reimplemented from QGpCoreTools::XMLClass.

Reimplemented in QGpCompatibility::CompatModalEllipticity.

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

{
  TRACE;
  _curves.xml_save(s, context);
}

Member Data Documentation

CompatModalCurves QGpCompatibility::CompatModalRefinedCurves::_curves [protected]

Referenced by addRayleighModes(), QGpCompatibility::CompatModalDispersion::CompatModalDispersion(), operator=(), setNOmegas(), toPointVector(), toStream(), writeReport(), xml_member(), and xml_writeChildren().

CompatRefineList QGpCompatibility::CompatModalRefinedCurves::_refines [protected]

Referenced by toPointVector(), toStream(), and writeReport().

const QString QGpCompatibility::CompatModalRefinedCurves::xmlModalRefinedCurvesTag = "ModalRefinedCurves" [static, protected]

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

QGpCompatibility/CompatModalRefinedCurves.h
QGpCompatibility/CompatModalRefinedCurves.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Member Function Documentation

Member Data Documentation