#include <CompatHodoChroneData.h>

Inheritance diagram for QGpCompatibility::CompatHodoChroneData:

Public Member Functions
void	calculate (RefractionDippingModel &model)
	CompatHodoChroneData ()
	default constructor
	CompatHodoChroneData (int modesCount, int omegasCount)
	Allocates an empty structure.
	CompatHodoChroneData (const CompatHodoChroneData *o, int modesCount)
	Allocates an empty structure based on an existing one with another number of modes.
	CompatHodoChroneData (const CompatMultiModalCurves *o)
	Set the values o as the measurements.
void	setSource (QString srcFile)
int	srcIndex (int iSrc)
void	valuesToData ()
void	valuesToData (CompatMultiModalCurves *o)

Constructor & Destructor Documentation

QGpCompatibility::CompatHodoChroneData::CompatHodoChroneData ( ) [inline]

default constructor

                        : 
      CompatHodoChrone(), CompatMultiModalData() {}

QGpCompatibility::CompatHodoChroneData::CompatHodoChroneData	(	int	modesCount,
		int	omegasCount
	)		`[inline]`

Allocates an empty structure.

                                                      :
      CompatHodoChrone(modesCount, omegasCount),
      CompatMultiModalData(modesCount, omegasCount) {}

QGpCompatibility::CompatHodoChroneData::CompatHodoChroneData	(	const CompatHodoChroneData *	o,
		int	modesCount
	)		`[inline]`

Allocates an empty structure based on an existing one with another number of modes.

                                                                     :
      CompatHodoChrone(o, modesCount),
      CompatMultiModalData(o, modesCount, CompatHODOCHRONE_INVALID_VALUE) {}

QGpCompatibility::CompatHodoChroneData::CompatHodoChroneData ( const CompatMultiModalCurves * o ) [inline]

Set the values o as the measurements.

                                                        :
      CompatHodoChrone(o),
      CompatMultiModalData(o) {}

Member Function Documentation

void QGpCompatibility::CompatHodoChroneData::calculate ( RefractionDippingModel & model )

{
  TRACE;
  model.setXLeft(_omegas[0]);
  model.setXRight(_omegas[CompatMultiModalFrequency::_omegasCount-1]);
  model.begin();
  TiltNode * nodes=new TiltNode [CompatMultiModalFrequency::_omegasCount];
  for(int iRec=0;iRec<CompatMultiModalFrequency::_omegasCount;iRec++) {
    nodes[iRec].init(_omegas[iRec],model);
  }
  
  int minTimeLayer;
  for(int iSrc=0;iSrc<CompatMultiModalFrequency::_modesCount;iSrc++) {
    double * measurements=_measurements[iSrc];
    double * value=_values[iSrc];
    int omegaISrc=srcIndex(iSrc);
    // Go towards negative receivers
    if(omegaISrc>0) {
      for(int iRec=0;iRec<omegaISrc;iRec++) {
        if(measurements[iRec]!=CompatHODOCHRONE_INVALID_VALUE) {
          value[iRec]=
              model.travelTime(nodes[omegaISrc], nodes[iRec], minTimeLayer);
         }
        else value[iRec]=CompatHODOCHRONE_INVALID_VALUE;
      }
    }
    value[omegaISrc]=0;
    // Go towards positive receivers
    if(omegaISrc<CompatMultiModalFrequency::_omegasCount-1) {
      for(int iRec=omegaISrc+1;iRec<CompatMultiModalFrequency::_omegasCount;iRec++) {
        if(measurements[iRec]!=CompatHODOCHRONE_INVALID_VALUE) {
          value[iRec]=
              model.travelTime(nodes[omegaISrc], nodes[iRec], minTimeLayer);
        }
        else value[iRec]=CompatHODOCHRONE_INVALID_VALUE;
      }
    }
  }
  delete [] nodes;
  model.end();
}

void QGpCompatibility::CompatHodoChroneData::setSource ( QString srcFile )

References QGpCompatibility::CompatMultiModalData::_measurements, QGpCompatibility::CompatMultiModalData::_modesCount, QGpCompatibility::CompatMultiModalFrequency::_omegasCount, QGpCompatibility::CompatMultiModalData::_omegasCount, QGpCompatibility::CompatMultiModalData::measurements(), srcIndex(), str, and TRACE.

{
  TRACE;
  QFile f(srcFile);
  if(!f.open(QIODevice::ReadOnly)) {
    fprintf(stderr," *** ERROR *** Cannot open source file\n");
    return;
  }
  QTextStream s(&f);
  QString str;
  int iSrc=0;
  for(iSrc=0;iSrc<CompatMultiModalFrequency::_modesCount;iSrc++) {
    double * measurements=_measurements[iSrc];
    for(int i=0;i<CompatMultiModalFrequency::_omegasCount;i++)
      measurements[i]=1;
  }
  iSrc=0;
  while(!s.atEnd()) {
    str=s.readLine().trimmed();
    if(!str.isEmpty() && str.left(1)!="#") {
      int srcIndex=str.section(QRegExp("[ \t]"),0,0).toInt();
      if(srcIndex>=0 && srcIndex<CompatMultiModalFrequency::_omegasCount)
        _measurements[iSrc][srcIndex]=0;
      else
        fprintf(stderr,"Receiver index out of range in CompatHodoChroneData::setSource\n");
      iSrc++;
      if(iSrc>=CompatMultiModalFrequency::_modesCount) break;
    }
  }  
}

int QGpCompatibility::CompatHodoChroneData::srcIndex ( int iSrc )

References QGpCompatibility::CompatMultiModalData::_measurements, QGpCompatibility::CompatMultiModalData::_omegasCount, QGpCompatibility::CompatMultiModalData::measurements(), and TRACE.

Referenced by calculate(), and setSource().

{
  TRACE;
  double * measurements=_measurements[iSrc];
  for(int i=0;i<CompatMultiModalFrequency::_omegasCount;i++) {
    if(measurements[i]==0) return i;
  }
  fprintf(stderr,"Error in CompatHodoChroneData no source location defined");
  return 0;
}

void QGpCompatibility::CompatHodoChroneData::valuesToData ( ) [inline]

References QGpCompatibility::CompatMultiModalData::valuesToData().

{CompatMultiModalData::valuesToData(this);}

void QGpCompatibility::CompatHodoChroneData::valuesToData ( CompatMultiModalCurves * o ) [inline]

Reimplemented from QGpCompatibility::CompatMultiModalData.

References QGpCompatibility::CompatMultiModalData::valuesToData().

{CompatMultiModalData::valuesToData(o);}

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

QGpCompatibility/CompatHodoChroneData.h
QGpCompatibility/CompatHodoChroneData.cpp

Public Member Functions

Constructor & Destructor Documentation

Member Function Documentation