#include <SPACLoop.h>
Public Member Functions | |
| virtual void | setArray (const ArrayStations &array) |
| void | setLoop (const SPACLoop *l) |
| void | setParameters (const SPACParameters *param) |
| SPACLoopTask () | |
| ~SPACLoopTask () | |
Protected Member Functions | |
| virtual void | run (int index) |
References ArrayCore::ArrayProcess::takeParameters(), and TRACE.
{
TRACE;
for(int iRing=0;iRing < _nRings; iRing++ ) {
delete [] _sum[iRing];
delete [] _sum2[iRing];
}
delete [] _sum;
delete [] _sum2;
// Parameters are not owned by process
_process->takeParameters();
delete _process;
}
| void SPACLoopTask::run | ( | int | index | ) | [protected, virtual] |
Implements QGpCoreTools::LoopTask.
References SPACLoop::addLog(), SPACLoop::array(), GeopsyCore::TimeRangeList::at(), ArrayCore::FrequencyBand::center(), GeopsyCore::StationList::components(), GeopsyCore::TimeRangeList::count(), QGpCoreWave::AutocorrCurves::curves(), QGpCoreTools::LoopTask::endIndex(), ArrayCore::ArrayProcess::frequency(), ArrayCore::RingCouplesProcess::horizontalAutocorr(), SPACLoop::lockOutputStmap(), ArrayCore::ArrayProcess::lockTimeWindow(), QGpCoreWave::AutocorrRing::maxRadius(), QGpCoreWave::AutocorrRing::minRadius(), SPACLoop::outputStmap(), ArrayCore::SPACArrayProcess::parameters(), ArrayCore::RingCouplesProcess::radialAutocorr(), ArrayCore::SPACParameters::ring(), ArrayCore::ArrayProcess::setFrequency(), QGpCoreTools::StatisticalValue< numberType >::setMean(), QGpCoreTools::LoopTask::setProgressMaximum(), QGpCoreTools::LoopTask::setProgressValue(), QGpCoreTools::LoopTask::setStatus(), QGpCoreTools::StatisticalValue< numberType >::setStddev(), QGpCoreTools::StatisticalValue< numberType >::setWeight(), QGpCoreTools::StatisticalPoint< numberType >::setX(), QGpCoreTools::sqrt(), SPACLoop::target(), QGpCoreTools::LoopTask::terminated(), ArrayCore::ArrayProcess::timeRangeList(), TRACE, ArrayCore::RingCouplesProcess::transverseAutocorr(), SPACLoop::unlockOutputStmap(), ArrayCore::ArrayProcess::unlockTimeWindow(), and ArrayCore::RingCouplesProcess::verticalAutocorr().
{
TRACE;
// Revert the order: start with expensive high frequencies
// When the number of cores increases and tends to the number
// of frequencies, it is more efficient to start with with the
// most expensive frequencies.
index=endIndex()-index-1;
QString freqLog, freqStatus;
_process->setFrequency(index, &freqLog, &freqStatus);
setStatus(freqStatus);
_loop->addLog(freqLog);
// Loop over all time windows
const TimeRangeList& winList=*_process->timeRangeList();
int nWin=winList.count();
resetStatistics();
setProgressMaximum(nWin);
for(int iWin=0;iWin < nWin; iWin++ ) {
if(terminated()) break;
setProgressValue(iWin);
_win=&winList.at(iWin);
if( !_process->lockTimeWindow(_win) ) continue;
for(int iRing=0;iRing < _nRings;iRing++ ) {
RingCouplesProcess& ring=_rings[iRing];
double * sumRing=_sum[iRing];
double * sum2Ring=_sum2[iRing];
double autocorrValue;
switch (_loop->array()->components()) {
case StationSignals::AllComponent: {
ring.horizontalAutocorr();
autocorrValue=ring.radialAutocorr();
sumRing[ 1 ] += autocorrValue;
sum2Ring[ 1 ] += autocorrValue * autocorrValue;
writeMax(1, iRing, autocorrValue);
autocorrValue=ring.transverseAutocorr();
sumRing[ 2 ] += autocorrValue;
sum2Ring[ 2 ] += autocorrValue * autocorrValue;
writeMax(2, iRing, autocorrValue);
}
case StationSignals::VerticalComponent: {
autocorrValue=ring.verticalAutocorr();
sumRing[ 0 ] += autocorrValue;
sum2Ring[ 0 ] += autocorrValue * autocorrValue;
writeMax(0, iRing, autocorrValue);
}
break;
}
}
_process->unlockTimeWindow();
}
// Compute statistics
double dNWin=(double) winList.count();
double invNWin=1.0/dNWin;
double invNWin1=1.0/(dNWin - 1.0);
double f=_process->frequency().center();
for(int iRing=0;iRing < _nRings; iRing++ ) {
double * sumRing=_sum[iRing];
double * sum2Ring=_sum2[iRing];
for(int iComp=0; iComp<_nComp; iComp++ ){
double tsum=sumRing[ iComp ] * invNWin;
double tsum2;
if(dNWin<=1) {
tsum2=0.0;
} else {
tsum2=(sum2Ring[iComp]-tsum*tsum*dNWin)*invNWin1;
if(tsum2<0.0) {
tsum2=0.0;
}
}
if(_loop->target()) {
ModalCurve& curve=_loop->target()->curves()[iRing*_nComp+iComp];
FactoryPoint& p=curve[index];
p.setX(f);
p.setMean(tsum);
p.setStddev(sqrt(tsum2));
p.setWeight(dNWin);
}
if(_loop->outputStmap(iComp)) {
_loop->lockOutputStmap(iComp);
const RingCouples& ring=_process->parameters()->ring(iRing);
QTextStream * s=new QTextStream(_loop->outputStmap(iComp));
(*s) << iRing << " "
<< index << " "
<< f << " "
<< tsum << " "
<< sqrt(tsum2) << " "
<< ring.minRadius()*0.001 << " "
<< ring.maxRadius()*0.001 << "\n";
delete s;
_loop->unlockOutputStmap(iComp);
}
}
}
}
| void SPACLoopTask::setArray | ( | const ArrayStations & | array | ) | [virtual] |
References ArrayCore::ArrayProcess::setTimeRangeList(), and TRACE.
Referenced by SPACLoop::newTask().
{
TRACE;
_process=new SPACArrayProcess(array);
_process->setTimeRangeList(new TimeWindowList);
}
| void SPACLoopTask::setLoop | ( | const SPACLoop * | l | ) | [inline] |
Referenced by SPACLoop::newTask().
{_loop=l;}
| void SPACLoopTask::setParameters | ( | const SPACParameters * | param | ) |
References SPACLoop::array(), GeopsyCore::StationList::nComponents(), ArrayCore::SPACParameters::ring(), ArrayCore::SPACParameters::ringCount(), ArrayCore::SPACArrayProcess::setParameters(), ArrayCore::ArrayProcess::stations(), and TRACE.
Referenced by SPACLoop::newTask().
{
TRACE;
_process->setParameters(param, true);
_nRings=param->ringCount();
_nComp=_loop->array()->nComponents();
_rings.resize(_nRings);
_sum=new double * [_nRings];
_sum2=new double * [_nRings];
for(int iRing=0; iRing<_nRings; iRing++ ){
_sum[iRing]=new double[_nComp];
_sum2[iRing]=new double[_nComp];
_rings[iRing].init(param->ring(iRing), _process->stations());
}
}
