All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines
Public Member Functions | Protected Member Functions
QGpCoreWave::AutocorrFactory Class Reference

Brief description of class still missing. More...

#include <AutocorrFactory.h>

Inheritance diagram for QGpCoreWave::AutocorrFactory:
QGpCoreWave::ModalFactory

List of all members.

Public Member Functions

 AutocorrFactory (const QVector< AutocorrRing > *rings)
void calculate (DispersionFactory *disp)
void calculate (double alphaR, DispersionFactory *disp)
void calculateHorizontal (double alphaR, DispersionFactory *disp)
void calculateHorizontal (int iOmega, double alphaR, DispersionFactory *disp)
void calculateVertical (DispersionFactory *disp)
int horizontalModeCount () const
void init ()
bool isRadial () const
bool isTransverse () const
bool isVertical () const
virtual const RealValue * mode (const Mode &m) const
ModalStorage & radial (int ringIndex) const
double radialAutocorr (double omega, double r1, double r2, double alpha, double cr, double cl)
int ringCount () const
virtual void setMode (const Mode &m)
virtual ModalStorage * storage (int storageIndex) const
virtual int storageCount () const
ModalStorage & transverse (int ringIndex) const
double transverseAutocorr (double omega, double r1, double r2, double alpha, double cr, double cl)
ModalStorage & vertical (int ringIndex) const
int verticalModeCount () const
virtual void writeReportHeader (QDataStream &s) const
 ~AutocorrFactory ()

Protected Member Functions

ModalStorage ** newHorizontalStorage ()
virtual ModalStorage * newStorage (int nModes)
void upgrade (ModalStorage **&s, int ringIndex, int requestedMode)

Detailed Description

Brief description of class still missing.

Full description of class still missing

Constructor & Destructor Documentation

QGpCoreWave::AutocorrFactory::AutocorrFactory ( const QVector< AutocorrRing > *  rings)

Description of constructor still missing

References TRACE.

{
  TRACE;
  _rings=rings;
  _vertical=0;
  _radial=0;
  _transverse=0;
  // internals
  /*_jRR=0;
  _jLR=0;
  _jRT=0;
  _jLT=0;
  _alpha=0;*/
}
QGpCoreWave::AutocorrFactory::~AutocorrFactory ( )

Description of destructor still missing

References TRACE.

{
  TRACE;
  int nRings=_rings->count();
  for(int i=0;i<nRings;i++) {
    if(_vertical) delete _vertical[i];
    if(_radial) delete _radial[i];
    if(_transverse) delete _transverse[i];
    /*if(_jRR) delete _jRR[i];
    if(_jLR) delete _jLR[i];
    if(_jRT) delete _jRT[i];
    if(_jLT) delete _jLT[i];*/
  }
  delete [] _vertical;
  delete [] _radial;
  delete [] _transverse;
  /*delete [] _jRR;
  delete [] _jLR;
  delete [] _jRT;
  delete [] _jLT;
  if(_alpha) {
    for(int i=0; i<_nHorizontalModes; i++) {
      delete [] _alpha[i];
    }
    delete [] _alpha;
  }*/
}

Member Function Documentation

void QGpCoreWave::AutocorrFactory::calculate ( DispersionFactory *  disp)

References calculateVertical(), isVertical(), and TRACE.

Referenced by DinverDCCore::TargetList::surfaceMisfit().

{
  TRACE;
  if(isVertical()) calculateVertical(disp);
  /* To be implemented correctly
  if(isRadial() || isTransverse()) {
    Dispersion& dispRayleigh=*disp->phaseRayleigh();
    Dispersion& dispLove=*disp->phaseLove();
    int nr=_rings->count();
    int nx=_x.count();
    ASSERT(_nHorizontalModes <= dispRayleigh.modeCount());
    ASSERT(_nHorizontalModes <= dispLove.modeCount());
    AutocorrEngine eng(x());
    for(int iMode=0;iMode < _nHorizontalModes;iMode++ ) {
      autocorr.setDispersion(dispRayleigh.mode(iMode), dispLove.mode(iMode) );
      for(int iRing=0;iRing < nr; iRing++ ) {
        if(_radial[iRing] && _transverse[iRing]) {
          autocorr.setRing(_rings->at(iRing), radial(iRing).mode(iMode), transverse(iRing).mode(iMode),
                            _jRR[iRing]->mode(iMode), _jLR[iRing]->mode(iMode), _jRT[iRing]->mode(iMode), _jLT[iRing]->mode(iMode));
          if(autocorr.isThinRing()) {
            for(int j=0;j < nx;j++ ) autocorr.horizontalThinRing(j);
          } else {
            for(int j=0;j < nx;j++ ) autocorr.horizontalThickRing(j);
          }
        }
      }
    }
  }*/
}
void QGpCoreWave::AutocorrFactory::calculate ( double  alphaR,
DispersionFactory *  disp 
)

References calculateHorizontal(), calculateVertical(), isRadial(), isTransverse(), isVertical(), and TRACE.

{
  TRACE;
  if(isVertical()) calculateVertical(disp);
  if(isRadial() || isTransverse()) calculateHorizontal(alphaR, disp);
}
void QGpCoreWave::AutocorrFactory::calculateHorizontal ( double  alphaR,
DispersionFactory *  disp 
)

References QGpCoreWave::ModalFactory::_x, QGpCoreWave::ModalStorage::mode(), QGpCoreWave::ModalStorage::modeCount(), QGpCoreWave::DispersionFactory::phaseLove(), QGpCoreWave::DispersionFactory::phaseRayleigh(), radial(), QGpCoreTools::Value< numberType >::setValid(), TRACE, transverse(), and QGpCoreWave::ModalFactory::x().

Referenced by calculate(), SpacReader::parse(), and Spac3CForward::setModel().

{
  TRACE;
  double alphaL=1.0 - alphaR;
  Dispersion& dispRayleigh=*disp->phaseRayleigh();
  Dispersion& dispLove=*disp->phaseLove();
  int nr=_rings->count();
  int nx=_x.count();
  ASSERT(_nHorizontalModes <= dispRayleigh.modeCount());
  ASSERT(_nHorizontalModes <= dispLove.modeCount());
  AutocorrEngine eng;
  for(int iMode=0;iMode < _nHorizontalModes;iMode++ ) {
    RealValue * dispR=dispRayleigh.mode(iMode);
    RealValue * dispL=dispLove.mode(iMode);
    for(int iRing=0;iRing < nr; iRing++ ) {
      if(_radial[iRing] && _transverse[iRing]) {
        eng.setHorizontalRing(_rings->at(iRing) );
        RealValue * autocorrR=radial(iRing).mode(iMode);
        RealValue * autocorrT=transverse(iRing).mode(iMode);
        if(eng.isThinRing()) {
          for(int ix=0; ix < nx; ix++ ) {
            if(eng.initHorizontalThinRing(x()->at(ix), dispR[ix], dispL[ix] )) {
              autocorrR[ix]=eng.radial(alphaR, alphaL);
              autocorrT[ix]=eng.transverse(alphaR, alphaL);
            } else {
              autocorrR[ix].setValid(false);
              autocorrT[ix].setValid(false);
            }
          }
        } else {
          for(int ix=0; ix < nx; ix++ ) {
            if(eng.initHorizontalThickRing(x()->at(ix), dispR[ix], dispL[ix] )) {
              autocorrR[ix]=eng.radial(alphaR, alphaL);
              autocorrT[ix]=eng.transverse(alphaR, alphaL);
            } else {
              autocorrR[ix].setValid(false);
              autocorrT[ix].setValid(false);
            }
          }
        }
      }
    }
  }
}
void QGpCoreWave::AutocorrFactory::calculateHorizontal ( int  iOmega,
double  alphaR,
DispersionFactory *  disp 
)

Calculation radial and transverse autocorrelations for the iOmega th frequency and for fundamental mode

References QGpCoreWave::ModalStorage::mode(), QGpCoreWave::ModalStorage::modeCount(), QGpCoreWave::DispersionFactory::phaseLove(), QGpCoreWave::DispersionFactory::phaseRayleigh(), radial(), QGpCoreTools::Value< numberType >::setValid(), TRACE, transverse(), and QGpCoreWave::ModalFactory::x().

{
  TRACE;
  double alphaL=1.0 - alphaR;
  Dispersion& dispRayleigh=*disp->phaseRayleigh();
  Dispersion& dispLove=*disp->phaseLove();
  int nr=_rings->count();
  ASSERT(_nHorizontalModes <= dispRayleigh.modeCount());
  ASSERT(_nHorizontalModes <= dispLove.modeCount());
  AutocorrEngine eng;
  RealValue * dispR=dispRayleigh.mode(0);
  RealValue * dispL=dispLove.mode(0);
  for(int iRing=0;iRing < nr; iRing++ ) {
    if(_radial[iRing] && _transverse[iRing]) {
      eng.setHorizontalRing(_rings->at(iRing) );
      RealValue * autocorrR=radial(iRing).mode(0);
      RealValue * autocorrT=transverse(iRing).mode(0);
      if(eng.isThinRing()) {
        if(eng.initHorizontalThinRing(x()->at(iOmega), dispR[iOmega], dispL[iOmega] )) {
          autocorrR[iOmega]=eng.radial(alphaR, alphaL);
          autocorrT[iOmega]=eng.transverse(alphaR, alphaL);
        } else {
          autocorrR[iOmega].setValid(false);
          autocorrT[iOmega].setValid(false);
        }
      } else {
        if(eng.initHorizontalThickRing(x()->at(iOmega), dispR[iOmega], dispL[iOmega] )) {
          autocorrR[iOmega]=eng.radial(alphaR, alphaL);
          autocorrT[iOmega]=eng.transverse(alphaR, alphaL);
        } else {
          autocorrR[iOmega].setValid(false);
          autocorrT[iOmega].setValid(false);
        }
      }
    }
  }
}
void QGpCoreWave::AutocorrFactory::calculateVertical ( DispersionFactory *  disp)

Calculate the autocorrelation curves from a dispersion curve for all possible modes Min(nModes(),disp.nModes())

References QGpCoreWave::ModalFactory::_x, QGpCoreWave::ModalStorage::mode(), QGpCoreWave::ModalStorage::modeCount(), QGpCoreWave::DispersionFactory::phaseRayleigh(), TRACE, vertical(), and QGpCoreWave::ModalFactory::x().

Referenced by calculate(), SpacReader::parse(), and Spac3CForward::setModel().

{
  TRACE;
  Dispersion& dispRayleigh=*disp->phaseRayleigh();
  int nr=_rings->count();
  int nx=_x.count();
  ASSERT(_nVerticalModes <= dispRayleigh.modeCount());
  AutocorrEngine eng;
  for(int iMode=0;iMode < _nVerticalModes;iMode++ ) {
    RealValue * dispR=dispRayleigh.mode(iMode);
    for(int iRing=0;iRing < nr; iRing++ ) {
      if(_vertical[iRing] ) {
        eng.setVerticalRing(_rings->at(iRing) );
        RealValue * autocorrV=vertical(iRing).mode(iMode);
        if(eng.isThinRing()) {
          for(int ix=0; ix < nx; ix++ )
            autocorrV[ix]=eng.verticalThinRing(x()->at(ix), dispR[ix] );
        } else {
          for(int ix=0; ix < nx; ix++ )
            autocorrV[ix]=eng.verticalThickRing(x()->at(ix), dispR[ix] );
        }
      }
    }
  }
}
int QGpCoreWave::AutocorrFactory::horizontalModeCount ( ) const

References TRACE.

Referenced by init(), and QGpCoreWave::DispersionFactory::validate().

{
  TRACE;
  int nm=maxModeCount(_radial);
  int nTransverse=maxModeCount(_transverse);
  if(nTransverse < nm) nm=nTransverse;
  return nm;
}
void QGpCoreWave::AutocorrFactory::init ( )

References horizontalModeCount(), isRadial(), isTransverse(), isVertical(), TRACE, and verticalModeCount().

Referenced by Spac3CForward::setCurves(), SpacReader::setOptions(), and DinverDCCore::TargetList::validateTargets().

{
  TRACE;
  if(isRadial() || isTransverse()) {
    //int nx=_x.count();
    _nHorizontalModes=horizontalModeCount();
    setInvalid(_radial);
    setInvalid(_transverse);
    //_jRR=newHorizontalStorage();
    //_jLR=newHorizontalStorage();
    //_jRT=newHorizontalStorage();
    //_jLT=newHorizontalStorage();
    /*_alpha=new RealStatisticalValue *[_nHorizontalModes];
    for(int i=0; i<_nHorizontalModes; i++) {
      RealStatisticalValue * s=new RealStatisticalValue[nx];
      for(int j=0; j<nx; j++) {
        s[j].setValid(false);
      }
      _alpha[i]=s;
    }*/
  }
  if(isVertical()) {
    _nVerticalModes=verticalModeCount();
    setInvalid(_vertical);
  }
}
bool QGpCoreWave::AutocorrFactory::isRadial ( ) const [inline]

Referenced by calculate(), and init().

{return _radial;}
bool QGpCoreWave::AutocorrFactory::isTransverse ( ) const [inline]

Referenced by calculate(), and init().

{return _transverse;}
bool QGpCoreWave::AutocorrFactory::isVertical ( ) const [inline]

Referenced by calculate(), and init().

{return _vertical;}
const RealValue * QGpCoreWave::AutocorrFactory::mode ( const Mode &  m) const [virtual]

Implements QGpCoreWave::ModalFactory.

References QGpCoreWave::Mode::index(), QGpCoreWave::ModalStorage::mode(), QGpCoreWave::Mode::polarisation(), QGpCoreWave::Mode::Radial, QGpCoreWave::Mode::ringIndex(), and QGpCoreWave::Mode::Transverse.

Referenced by Spac3CForward::misfit().

{
  switch (m.polarisation()) {
  case Mode::Radial:
    return _radial ? _radial[m.ringIndex()]->mode(m.index()) : 0;
  case Mode::Transverse:
    return _transverse ? _transverse[m.ringIndex()]->mode(m.index()) : 0;
  default:
    return _vertical ? _vertical[m.ringIndex()]->mode(m.index()) : 0;
  }
}
ModalStorage ** QGpCoreWave::AutocorrFactory::newHorizontalStorage ( ) [protected]

References newStorage(), and TRACE.

{
  TRACE;
  int nRings=_rings->count();
  ModalStorage ** s=new ModalStorage * [nRings];
  for(int i=0;i<nRings;i++) {
    if(_radial[i] && _transverse[i] ) {
      s[i]=newStorage(_nHorizontalModes);
    } else {
      s[i]=0;
    }
  }
  return s;
}
virtual ModalStorage* QGpCoreWave::AutocorrFactory::newStorage ( int  nModes) [inline, protected, virtual]

Implements QGpCoreWave::ModalFactory.

Referenced by newHorizontalStorage().

{return new ModalStorage (nModes, x());}
ModalStorage& QGpCoreWave::AutocorrFactory::radial ( int  ringIndex) const [inline]

Referenced by calculateHorizontal(), SpacReader::parse(), and Spac3CForward::radial().

{return *_radial[ringIndex];}
double QGpCoreWave::AutocorrFactory::radialAutocorr ( double  omega,
double  r1,
double  r2,
double  alpha,
double  cr,
double  cl 
)

Unoptimized litteral impletation, for testing only

References TRACE.

{
  TRACE;
  //printf("%lf: %lf %lf %lf %lf %lf\n",omega, r1, r2, alpha, cr,cl);
  double omegaR1=omega*r1/cr; 
  double omegaR2=omega*r2/cr; 
  double omegaL1=omega*r1/cl; 
  double omegaL2=omega*r2/cl; 
  return 4/(r2*r2-r1*r1)*(alpha*cr/omega*(cr/omega*(j0(omegaR2)-j0(omegaR1))+(r2*j1(omegaR2)-r1*j1(omegaR1)))-(1-alpha)*cl*cl/(omega*omega)*(j0(omegaL2)-j0(omegaL1)));
}
int QGpCoreWave::AutocorrFactory::ringCount ( ) const [inline] 
{return _rings->count();}
void QGpCoreWave::AutocorrFactory::setMode ( const Mode &  m) [virtual]

Implements QGpCoreWave::ModalFactory.

References QGpCoreWave::Mode::index(), QGpCoreWave::Mode::polarisation(), QGpCoreWave::Mode::Radial, QGpCoreWave::Mode::ringIndex(), TRACE, QGpCoreWave::Mode::Transverse, and upgrade().

Referenced by SpacReader::setOptions().

{
  TRACE;
  switch (m.polarisation()) {
  case Mode::Radial:
    upgrade(_radial, m.ringIndex(), m.index()); break;
  case Mode::Transverse:
    upgrade(_transverse, m.ringIndex(), m.index()); break;
  default:
    upgrade(_vertical, m.ringIndex(), m.index()); break;
  }
}
ModalStorage * QGpCoreWave::AutocorrFactory::storage ( int  storageIndex) const [inline, virtual]

Implements QGpCoreWave::ModalFactory.

References TRACE.

{
  TRACE;
  int iRing=storageIndex/3;
  int iComponent=storageIndex-iRing*3;
  switch (iComponent) {
  case 1:
    if(_radial) return _radial[iRing]; else return 0;
  case 2:
    if(_transverse) return _transverse[iRing]; else return 0;
  default:
    if(_vertical) return _vertical[iRing]; else return 0;
  }
}
virtual int QGpCoreWave::AutocorrFactory::storageCount ( ) const [inline, virtual]

Implements QGpCoreWave::ModalFactory.

{return _rings->count()*3;}
ModalStorage& QGpCoreWave::AutocorrFactory::transverse ( int  ringIndex) const [inline]

Referenced by calculateHorizontal(), SpacReader::parse(), and Spac3CForward::transverse().

{return *_transverse[ringIndex];}
double QGpCoreWave::AutocorrFactory::transverseAutocorr ( double  omega,
double  r1,
double  r2,
double  alpha,
double  cr,
double  cl 
)

Unoptimized litteral impletation, for testing only

References TRACE.

{
  TRACE;
  double omegaR1=omega*r1/cr; 
  double omegaR2=omega*r2/cr; 
  double omegaL1=omega*r1/cl; 
  double omegaL2=omega*r2/cl; 
  return 4/(r2*r2-r1*r1)*(-alpha*cr*cr/(omega*omega)*(j0(omegaR2)-j0(omegaR1))+(1-alpha)*cl/omega*(cl/omega*(j0(omegaL2)-j0(omegaL1))+(r2*j1(omegaL2)-r1*j1(omegaL1))));
}
void QGpCoreWave::AutocorrFactory::upgrade ( ModalStorage **&  s,
int  ringIndex,
int  requestedMode 
) [protected]

References TRACE.

Referenced by setMode().

{
  TRACE;
  if( !s) {
    int nRings=_rings->count();
    s=new ModalStorage * [nRings];
    for(int i=0;i<nRings;i++) {
      s[i]=0;
    }
  }
  ModalFactory::upgrade<ModalStorage>(s[ringIndex], requestedMode);
}
ModalStorage& QGpCoreWave::AutocorrFactory::vertical ( int  ringIndex) const [inline]

Referenced by calculateVertical(), Spac3CForward::omega(), SpacReader::parse(), and Spac3CForward::vertical().

{return *_vertical[ringIndex];}
int QGpCoreWave::AutocorrFactory::verticalModeCount ( ) const [inline]

Referenced by init(), and QGpCoreWave::DispersionFactory::validate().

{return maxModeCount(_vertical);}
void QGpCoreWave::AutocorrFactory::writeReportHeader ( QDataStream &  s) const [inline, virtual]

Reimplemented from QGpCoreWave::ModalFactory.

References TRACE.

{
  TRACE;
  s << _rings->count();
}
The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines

Modified 2013-10-22

Valid CSS! Valid XHTML 1.0!