#include <CompatAutocorrReport.h>

Inheritance diagram for QGpCompatibility::CompatAutocorrReport:

Public Member Functions
void	addAutocorrGoal (CompatAutocorrData *ad)
void	addModel (const Seismic1DModel model, float naModel, const CompatDispersion disp, const CompatAutocorrCurves ac, double cost, int modelID=-1)
	Add all block in one time with extension of autocorr curves.
void	addModel (const Seismic1DModel model, float naModel, const CompatDispersion disp, const CompatEllipticity ell, const CompatAutocorrCurves *ac, double cost, int modelID=-1)
	Add all block in one time with extension of autocorr curves.
	CompatAutocorrReport (bool isWrite, QString reportFile, QString naInFile=QString::null, int nModels=0)
	Constructor: open file.
CompatAutocorrCurves *	currentAutocorr ()
	Returns the autocorr curves of current model.
virtual bool	isA (const char *className)
	Test whether this class is of type className.
bool	loadAutocorr (int modelIndex)
	load the model, the cost, he dispersion curve and the autocorr curve
bool	loadAutocorr (CompatAutocorrCurves *ac, int modelIndex)
	Same as above except that it loads the dispersion curve in a given dispersion object.
CompatAutocorrData *	loadAutocorrGoal ()
	load the measured autocorr curves into a new autocorrData class
bool	loadAutocorrOnly (int modelIndex)
	load the autocorr curve only
void	modifyAutocorrGoal (CompatAutocorrData *rms)
int	radiusCount ()
	~CompatAutocorrReport ()
Protected Member Functions
bool	initCurrentAutocorr ()
	initialize current autocorrCurves object
Protected Attributes
CompatAutocorrCurves *	_currentAutocorr
	Last autocorr object loaded from stream.

Constructor & Destructor Documentation

QGpCompatibility::CompatAutocorrReport::CompatAutocorrReport	(	bool	isWrite,
		QString	reportFile,
		QString	naInFile = `QString::null`,
		int	nModels = `0`
	)

Constructor: open file.

References _currentAutocorr, and TRACE.

                                                                                                          :
    CompatInversionReport(isWrite, reportFile, naInFile, nModels)
{
  TRACE;
  _currentAutocorr=0;
}

QGpCompatibility::CompatAutocorrReport::~CompatAutocorrReport ( )

References _currentAutocorr, and TRACE.

{
  TRACE;
  delete _currentAutocorr;
}

Member Function Documentation

void QGpCompatibility::CompatAutocorrReport::addAutocorrGoal ( CompatAutocorrData * ad )

{
  TRACE;
  // tests if omegas are entered
  if( !startReadingBlock(_blockOmegas, Omegas) ) {
    fprintf(stderr, "You must call addOmegas before calling addDispersionGoal\n" );
    return ;
  }
  startWritingBlock(AutocorrGoal);
  if(ad) {
    _s << ad->rayleighModesCount();
    ad->dataToReport(_s);
  }
  endWritingBlock();
}

void QGpCompatibility::CompatAutocorrReport::addModel	(	const Seismic1DModel *	model,
		float *	naModel,
		const CompatDispersion *	disp,
		const CompatAutocorrCurves *	ac,
		double	cost,
		int	modelID = `-1`
	)

Add all block in one time with extension of autocorr curves.

References QGpCompatibility::CompatInversionReport::_currentID, QGpCompatibility::CompatInversionReport::_s, QGpCompatibility::CompatInversionReport::endWritingBlock(), QGpCompatibility::CompatInversionReport::ModelDispersion, QGpCompatibility::CompatMultiModalCurves::refinesCount(), QGpCompatibility::CompatMultiModalCurves::refinesToReport(), QGpCompatibility::CompatInversionReport::setMaxOmegasCount(), QGpCompatibility::CompatInversionReport::startWritingBlock(), QGpCoreWave::Seismic1DModel::toStream(), TRACE, QGpCompatibility::CompatMultiModalCurves::valuesToReport(), QGpCompatibility::CompatAutocorrCurves::valuesToReport(), and QGpCompatibility::CompatInversionReport::writeNAModel().

{
  TRACE;
  // Write new model at the end of file
  if(startWritingBlock( ModelDispersion) ) {
    if(modelID < 0) {
      _s << _currentID;
      _currentID++;
    } else {
      if(modelID >= _currentID) _currentID=modelID + 1;
      _s << modelID;
    }
    model->toStream(_s);
    _s << cost;
    writeNAModel(naModel);
    disp->valuesToReport(_s);
    disp->refinesToReport(_s);
    ac->valuesToReport(_s);
  } else fprintf(stderr, "Maximum number of models is reached, model not added\n" );
  endWritingBlock();
  setMaxOmegasCount(disp->refinesCount(), 0);
}

void QGpCompatibility::CompatAutocorrReport::addModel	(	const Seismic1DModel *	model,
		float *	naModel,
		const CompatDispersion *	disp,
		const CompatEllipticity *	ell,
		const CompatAutocorrCurves *	ac,
		double	cost,
		int	modelID = `-1`
	)

Add all block in one time with extension of autocorr curves.

References QGpCompatibility::CompatInversionReport::_currentID, QGpCompatibility::CompatInversionReport::_s, QGpCompatibility::CompatInversionReport::endWritingBlock(), QGpCompatibility::CompatInversionReport::ModelDispersion, QGpCompatibility::CompatMultiModalCurves::refinesCount(), QGpCompatibility::CompatMultiModalCurves::refinesToReport(), QGpCompatibility::CompatInversionReport::setMaxOmegasCount(), QGpCompatibility::CompatInversionReport::startWritingBlock(), QGpCoreWave::Seismic1DModel::toStream(), TRACE, QGpCompatibility::CompatMultiModalCurves::valuesToReport(), QGpCompatibility::CompatAutocorrCurves::valuesToReport(), and QGpCompatibility::CompatInversionReport::writeNAModel().

{
  TRACE;
  // Write new model at the end of file
  if(startWritingBlock( ModelDispersion) ) {
    if(modelID < 0) {
      _s << _currentID;
      _currentID++;
    } else {
      if(modelID >= _currentID) _currentID=modelID + 1;
      _s << modelID;
    }
    model->toStream(_s);
    _s << cost;
    writeNAModel(naModel);
    disp->valuesToReport(_s);
    disp->refinesToReport(_s);
    ell->valuesToReport(_s);
    ell->refinesToReport(_s);
    ac->valuesToReport(_s);
  } else fprintf(stderr, "Maximum number of models is reached, model not added\n" );
  endWritingBlock();
  setMaxOmegasCount(disp->refinesCount(), ell->refinesCount());
}

CompatAutocorrCurves * QGpCompatibility::CompatAutocorrReport::currentAutocorr ( ) [inline]

Returns the autocorr curves of current model.

References _currentAutocorr, loadAutocorr(), and TRACE.

{
  TRACE;
  if(!_currentAutocorr) loadAutocorr(0);  
  return _currentAutocorr;
}

bool QGpCompatibility::CompatAutocorrReport::initCurrentAutocorr ( ) [protected]

initialize current autocorrCurves object

Referenced by loadAutocorr(), loadAutocorrGoal(), and loadAutocorrOnly().

{
  TRACE;
  ASSERT( !_currentAutocorr);
  _currentAutocorr=new CompatAutocorrCurves();
  if(startReadingBlock( _blockGoal, AutocorrGoal) ) {
    if(_version >= 2) {
      uint rayleighModesCount;
      _s >> rayleighModesCount;
      _currentAutocorr->setRayleighModesCount(rayleighModesCount);
    }
    _currentAutocorr->reportToRadius(_s);
    if(startReadingBlock( _blockOmegas, Omegas) )
      _currentAutocorr->reportToOmega(_s);
    else {
      Message::critical(MSG_ID,"Inversion report", "Omegas at index 1", Message::cancel());
      return false;
    }
  } else Message::critical(MSG_ID,"Inversion report", "Radius at index 2", Message::cancel());
  if(_version < 2)
    _currentAutocorr->setRayleighModesCount(_currentAutocorr->modesCount());
  return true;
}

bool QGpCompatibility::CompatAutocorrReport::isA ( const char * className ) [virtual]

Test whether this class is of type className.

Reimplemented from QGpCompatibility::CompatInversionReport.

References TRACE.

{
  TRACE;
  return strcmp(className, "CompatAutocorrReport" )==0;
}

bool QGpCompatibility::CompatAutocorrReport::loadAutocorr ( int modelIndex )

load the model, the cost, he dispersion curve and the autocorr curve

Referenced by currentAutocorr(), and radiusCount().

{
  TRACE;
  if( !_currentModel) initCurrentModel();
  if( !_currentNAModel) _currentNAModel=new float [ _nd ];
  if( !_currentDispersion) initCurrentDispersion();
  if( !_currentAutocorr && !initCurrentAutocorr()) return false;
  if(startReadingBlock( modelIndex + _headerBlocksCount, ModelDispersion) ) {
    _s >> _currentID;
    _currentModel->fromStream(_s);
    _s >> _currentCost;
    if(_version >= 4) _s.readRawData(( char * ) _currentNAModel, _nd * sizeof(float) );
    _currentDispersion->reportToValues(_s);
    if(_version > 0) _currentDispersion->reportToRefines(_s);
    if(_currentEllipticity) {
      _currentEllipticity->reportToValues(_s);
      if(_version > 0) _currentEllipticity->reportToRefines(_s);
    }
    _currentAutocorr->reportToValues(_s);
  } else _currentCost=-1;
  return true;
}

bool QGpCompatibility::CompatAutocorrReport::loadAutocorr	(	CompatAutocorrCurves *	ac,
		int	modelIndex
	)

Same as above except that it loads the dispersion curve in a given dispersion object.

{
  TRACE;
  if( !_currentModel) initCurrentModel();
  if( !_currentNAModel) _currentNAModel=new float [ _nd ];
  if( !_currentDispersion) initCurrentDispersion();
  if(startReadingBlock( _blockGoal, AutocorrGoal) ) {
    ac->reportToRadius(_s);
    if(startReadingBlock( _blockOmegas, Omegas) ) {
      ac->reportToOmega(_s);
      if(startReadingBlock( modelIndex + _headerBlocksCount, ModelDispersion) ) {
        _s >> _currentID;
        _currentModel->fromStream(_s);
        _s >> _currentCost;
        if(_version >= 4) _s.readRawData(( char * ) _currentNAModel, _nd * sizeof(float) );
        _currentDispersion->reportToValues(_s);
        if(_version > 0) _currentDispersion->reportToRefines(_s);
        if(_currentEllipticity) {
          _currentEllipticity->reportToValues(_s);
          if(_version > 0) _currentEllipticity->reportToRefines(_s);
        }
        ac->reportToValues(_s);
      }
    } else {
      Message::critical(MSG_ID,"Inversion report", "Omegas at index 1", Message::cancel());
      return false;
    }
  } else {
    Message::critical(MSG_ID,"Inversion report", "Radius at index 2", Message::cancel());
    return false;
  }
  return true;
}

CompatAutocorrData * QGpCompatibility::CompatAutocorrReport::loadAutocorrGoal ( )

load the measured autocorr curves into a new autocorrData class

{
  TRACE;
  if( !_currentAutocorr) initCurrentAutocorr();
  CompatAutocorrData * ad=new CompatAutocorrData(_currentAutocorr);
  if(startReadingBlock( _blockGoal, AutocorrGoal) ) {
    if(_version >= 2) {
      uint rayleighModesCount;
      _s >> rayleighModesCount;
      ad->setRayleighModesCount(rayleighModesCount);
    }
    ad->reportToData(_s);
    ad->reportToDataWeight(_s, _version >= 3);
  } else fprintf(stderr, "Unable to read block AutocorrGoal in current file\n" );
  return ad;
}

bool QGpCompatibility::CompatAutocorrReport::loadAutocorrOnly ( int modelIndex )

load the autocorr curve only

{
  TRACE;
  if( !_currentModel) initCurrentModel();
  if( !_currentNAModel) _currentNAModel=new float [ _nd ];
  if( !_currentDispersion) initCurrentDispersion();
  if( !_currentAutocorr && !initCurrentAutocorr()) return false;
  if(startReadingBlock( modelIndex + _headerBlocksCount, ModelDispersion) ) {
    // ID, Model, cost and basic dispersion offset
    int nRefines;
    qint64 blockOffset=_s.device() ->pos();
    int offset=(_currentDispersion->modesCount() * _currentDispersion->omegasCount() +
                   4 * _currentModel->layerCount()) * sizeof(double) + 2 * sizeof(int);
    if(_version >= 4) offset += _nd * sizeof(float);
    if(_version >= 1) {
      _s.device() ->seek(blockOffset + offset);
      _s >> nRefines;
      offset += sizeof(int) + nRefines * 2 * sizeof(double);
    }
    if(_currentEllipticity) {
      offset += _currentDispersion->modesCount() * _currentDispersion->omegasCount() *
                sizeof(double);
      if(_version >= 1) {
        _s.device() ->seek(blockOffset + offset);
        _s >> nRefines;
        offset += sizeof(int) + nRefines * 2 * sizeof(double);
      }
    }
    _s.device() ->seek(blockOffset + offset);
    _currentAutocorr->reportToValues(_s);
  }
  return true;
}

void QGpCompatibility::CompatAutocorrReport::modifyAutocorrGoal ( CompatAutocorrData * rms )

Re-writing over the existing goal curves, extrem caution may be observe to the size of the new CompatAutocorrData: it must be exactly the same structure as the one added with addAutocorrGoal(), only some changes in the values are tolerated

References QGpCompatibility::CompatInversionReport::_blockGoal, QGpCompatibility::CompatInversionReport::_s, QGpCompatibility::CompatInversionReport::AutocorrGoal, QGpCompatibility::CompatAutocorrData::dataToReport(), QGpCompatibility::CompatInversionReport::endWritingBlock(), QGpCompatibility::CompatAutocorrCurves::rayleighModesCount(), QGpCompatibility::CompatInversionReport::startWritingBlock(), and TRACE.

{
  TRACE;
  startWritingBlock(_blockGoal, AutocorrGoal);
  if(ad) {
    _s << ad->rayleighModesCount();
    ad->dataToReport(_s);
  }
  endWritingBlock();
}

int QGpCompatibility::CompatAutocorrReport::radiusCount ( ) [inline]

References _currentAutocorr, loadAutocorr(), QGpCompatibility::CompatAutocorrCurves::radiusCount(), and TRACE.

{
  TRACE;
  if(!_currentAutocorr) loadAutocorr(0);  
  return _currentAutocorr->radiusCount();
}

Member Data Documentation

CompatAutocorrCurves* QGpCompatibility::CompatAutocorrReport::_currentAutocorr [protected]

Last autocorr object loaded from stream.

Referenced by CompatAutocorrReport(), currentAutocorr(), initCurrentAutocorr(), loadAutocorr(), loadAutocorrGoal(), loadAutocorrOnly(), radiusCount(), and ~CompatAutocorrReport().

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

QGpCompatibility/CompatAutocorrReport.h
QGpCompatibility/CompatAutocorrReport.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation