[seiscomp, scanloc] Install, add .gitignore
This commit is contained in:
352
include/seiscomp/processing/operator/ncomps.ipp
Normal file
352
include/seiscomp/processing/operator/ncomps.ipp
Normal file
@ -0,0 +1,352 @@
|
||||
/***************************************************************************
|
||||
* Copyright (C) gempa GmbH *
|
||||
* All rights reserved. *
|
||||
* Contact: gempa GmbH (seiscomp-dev@gempa.de) *
|
||||
* *
|
||||
* GNU Affero General Public License Usage *
|
||||
* This file may be used under the terms of the GNU Affero *
|
||||
* Public License version 3.0 as published by the Free Software Foundation *
|
||||
* and appearing in the file LICENSE included in the packaging of this *
|
||||
* file. Please review the following information to ensure the GNU Affero *
|
||||
* Public License version 3.0 requirements will be met: *
|
||||
* https://www.gnu.org/licenses/agpl-3.0.html. *
|
||||
* *
|
||||
* Other Usage *
|
||||
* Alternatively, this file may be used in accordance with the terms and *
|
||||
* conditions contained in a signed written agreement between you and *
|
||||
* gempa GmbH. *
|
||||
***************************************************************************/
|
||||
|
||||
|
||||
#include <seiscomp/core/datetime.h>
|
||||
#include <seiscomp/core/typedarray.h>
|
||||
#include <seiscomp/core/bitset.h>
|
||||
|
||||
|
||||
namespace Seiscomp {
|
||||
namespace Processing {
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
struct ScopedUnsetFlag {
|
||||
ScopedUnsetFlag(bool &f) : flag(f) {}
|
||||
~ScopedUnsetFlag() { flag = false; }
|
||||
bool &flag;
|
||||
};
|
||||
|
||||
template <typename T, int N, class PROC, int BSIZE>
|
||||
WaveformProcessor::Status NCompsOperator<T,N,PROC,BSIZE>::process(int, const Record *rec) {
|
||||
Core::Time minStartTime;
|
||||
Core::Time maxStartTime;
|
||||
Core::Time minEndTime;
|
||||
WaveformProcessor::Status status;
|
||||
|
||||
status = WaveformProcessor::WaitingForData;
|
||||
|
||||
ScopedUnsetFlag unsetProcessingFlagOnReturn(_processing);
|
||||
_processing = true;
|
||||
|
||||
for ( int i = 0; i < N; ++i ) {
|
||||
// Not all traces available, nothing to do
|
||||
if ( _states[i].endTime.valid() ) {
|
||||
if ( _states[i].endTime > minStartTime )
|
||||
minStartTime = _states[i].endTime;
|
||||
}
|
||||
|
||||
if ( _states[i].buffer.empty() ) {
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
// Find common start time for all three components
|
||||
RecordSequence::iterator it[N];
|
||||
RecordSequence::iterator it_end[N];
|
||||
int maxStartComponent;
|
||||
int skips;
|
||||
double samplingFrequency, timeTolerance;
|
||||
|
||||
// Initialize iterators for each component
|
||||
for ( int i = 0; i < N; ++i )
|
||||
it[i] = _states[i].buffer.begin();
|
||||
|
||||
// Store sampling frequency of first record of first component
|
||||
// All records must match this sampling frequency
|
||||
samplingFrequency = (*it[0])->samplingFrequency();
|
||||
timeTolerance = 0.5 / samplingFrequency;
|
||||
|
||||
while ( true ) {
|
||||
if ( minStartTime ) {
|
||||
for ( int i = 0; i < N; ++i ) {
|
||||
while ( it[i] != _states[i].buffer.end() ) {
|
||||
if ( (*it[i])->endTime() <= minStartTime )
|
||||
it[i] = _states[i].buffer.erase(it[i]);
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
||||
// End of stream?
|
||||
if ( it[i] == _states[i].buffer.end() )
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
// Advance all other components to first record matching
|
||||
// the first sampling frequency found
|
||||
for ( int i = 0; i < N; ++i ) {
|
||||
if ( ((*it[i])->samplingFrequency() != samplingFrequency) )
|
||||
return WaveformProcessor::InvalidSamplingFreq;
|
||||
}
|
||||
|
||||
// Find maximum start time of all three records
|
||||
skips = 1;
|
||||
while ( skips ) {
|
||||
maxStartComponent = -1;
|
||||
|
||||
for ( int i = 0; i < N; ++i ) {
|
||||
if ( !i || maxStartTime < (*it[i])->startTime() ) {
|
||||
maxStartTime = (*it[i])->startTime();
|
||||
maxStartComponent = i;
|
||||
}
|
||||
}
|
||||
|
||||
skips = 0;
|
||||
|
||||
// Check all other components against maxStartTime
|
||||
for ( int i = 0; i < N; ++i ) {
|
||||
if ( i == maxStartComponent ) continue;
|
||||
|
||||
while ( (*it[i])->endTime() <= maxStartTime ) {
|
||||
if ( (*it[i])->samplingFrequency() != samplingFrequency )
|
||||
return WaveformProcessor::InvalidSamplingFreq;
|
||||
|
||||
++it[i];
|
||||
|
||||
// End of sequence? Nothing can be done anymore
|
||||
if ( it[i] == _states[i].buffer.end() )
|
||||
return status;
|
||||
|
||||
// Increase skip counter
|
||||
++skips;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Advance all iterators to last non-gappy record
|
||||
for ( int i = 0; i < N; ++i ) {
|
||||
RecordSequence::iterator tmp = it[i];
|
||||
it_end[i] = it[i];
|
||||
++it_end[i];
|
||||
while ( it_end[i] != _states[i].buffer.end() ) {
|
||||
const Record *rec = it_end[i]->get();
|
||||
|
||||
// Skip records with wrong sampling frequency
|
||||
if ( rec->samplingFrequency() != samplingFrequency )
|
||||
return WaveformProcessor::InvalidSamplingFreq;
|
||||
|
||||
double diff = (double)(rec->startTime()-(*tmp)->endTime());
|
||||
if ( fabs(diff) > timeTolerance ) break;
|
||||
|
||||
tmp = it_end[i];
|
||||
++it_end[i];
|
||||
}
|
||||
|
||||
it_end[i] = tmp;
|
||||
}
|
||||
|
||||
// Find minimum end time of all three records
|
||||
for ( int i = 0; i < N; ++i ) {
|
||||
if ( !i || minEndTime > (*it_end[i])->endTime() )
|
||||
minEndTime = (*it_end[i])->endTime();
|
||||
}
|
||||
|
||||
typedef typename Core::SmartPointer< NumericArray<T> >::Impl DataArrayPtr;
|
||||
|
||||
DataArrayPtr data[N];
|
||||
GenericRecordPtr comps[N];
|
||||
|
||||
int minLen = 0;
|
||||
|
||||
// Clip maxStartTime to minStartTime
|
||||
if ( maxStartTime < minStartTime )
|
||||
maxStartTime = minStartTime;
|
||||
|
||||
BitSetPtr clipMask;
|
||||
|
||||
// Align records
|
||||
for ( int i = 0; i < N; ++i ) {
|
||||
float tq = 0;
|
||||
int tqCount = 0;
|
||||
|
||||
if ( _proc.publish(i) )
|
||||
comps[i] = new GenericRecord((*it[i])->networkCode(),
|
||||
(*it[i])->stationCode(),
|
||||
(*it[i])->locationCode(),
|
||||
_proc.translateChannelCode(i, (*it[i])->channelCode()),
|
||||
maxStartTime, samplingFrequency);
|
||||
|
||||
data[i] = new NumericArray<T>;
|
||||
RecordSequence::iterator seq_end = it_end[i];
|
||||
++seq_end;
|
||||
|
||||
for ( RecordSequence::iterator rec_it = it[i]; rec_it != seq_end; ) {
|
||||
const Array *rec_data = (*rec_it)->data();
|
||||
if ( (*rec_it)->startTime() > minEndTime )
|
||||
break;
|
||||
|
||||
++it[i];
|
||||
|
||||
const NumericArray<T> *srcData = NumericArray<T>::ConstCast(rec_data);
|
||||
typename Core::SmartPointer< NumericArray<T> >::Impl tmp;
|
||||
if ( srcData == nullptr ) {
|
||||
tmp = (NumericArray<T>*)rec_data->copy(NumericArray<T>::ArrayType);
|
||||
srcData = tmp.get();
|
||||
}
|
||||
|
||||
int startIndex = 0;
|
||||
int endIndex = srcData->size();
|
||||
|
||||
if ( (*rec_it)->startTime() < maxStartTime )
|
||||
startIndex += (int)(double(maxStartTime-(*rec_it)->startTime())*(*rec_it)->samplingFrequency()+0.5);
|
||||
|
||||
if ( (*rec_it)->endTime() > minEndTime )
|
||||
endIndex -= (int)(double((*rec_it)->endTime()-minEndTime)*(*rec_it)->samplingFrequency());
|
||||
|
||||
int len = endIndex-startIndex;
|
||||
// Skip empty records
|
||||
if ( len <= 0 ) {
|
||||
++rec_it;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ( (*rec_it)->timingQuality() >= 0 ) {
|
||||
tq += (*rec_it)->timingQuality();
|
||||
++tqCount;
|
||||
}
|
||||
|
||||
// Combine the clip masks with OR if available
|
||||
const BitSet *recClipMask = (*rec_it)->clipMask();
|
||||
if ( (recClipMask != nullptr) && recClipMask->any() ) {
|
||||
int ofs = data[i]->size();
|
||||
int nBits = data[i]->size() + len;
|
||||
if ( !clipMask )
|
||||
clipMask = new BitSet(nBits);
|
||||
else if ( (int)clipMask->size() < nBits )
|
||||
clipMask->resize(nBits, false);
|
||||
|
||||
for ( int i = startIndex; i < len; ++i, ++ofs )
|
||||
clipMask->set(ofs, clipMask->test(ofs) || recClipMask->test(i));
|
||||
}
|
||||
|
||||
data[i]->append(len, srcData->typedData()+startIndex);
|
||||
|
||||
++rec_it;
|
||||
}
|
||||
|
||||
if ( comps[i] && (tqCount > 0) )
|
||||
comps[i]->setTimingQuality((int)(tq / tqCount));
|
||||
|
||||
minLen = i==0?data[i]->size():std::min(minLen, data[i]->size());
|
||||
|
||||
if ( comps[i] ) comps[i]->setData(data[i].get());
|
||||
}
|
||||
|
||||
// Trim clip mask to sample array size
|
||||
if ( clipMask ) {
|
||||
if ( (int)clipMask->size() > minLen )
|
||||
clipMask->resize(minLen);
|
||||
// Destroy clip mask if no bit is set
|
||||
if ( !clipMask->any() )
|
||||
clipMask = nullptr;
|
||||
}
|
||||
|
||||
T *data_samples[N];
|
||||
|
||||
for ( int i = 0; i < N; ++i ) {
|
||||
NumericArray<T> *ar = data[i].get();
|
||||
if ( ar->size() > minLen ) {
|
||||
ar->resize(minLen);
|
||||
if ( comps[i] ) comps[i]->dataUpdated();
|
||||
}
|
||||
|
||||
data_samples[i] = data[i]->typedData();
|
||||
|
||||
Core::Time endTime = maxStartTime + Core::TimeSpan(data[i]->size() / rec->samplingFrequency());
|
||||
|
||||
// Set last transformed end time of component
|
||||
if ( !_states[i].endTime.valid() ||
|
||||
_states[i].endTime < endTime ) {
|
||||
_states[i].endTime = endTime;
|
||||
}
|
||||
}
|
||||
|
||||
if ( minLen > 0 ) {
|
||||
// Process finally
|
||||
try {
|
||||
_proc(rec, data_samples, minLen, maxStartTime, rec->samplingFrequency());
|
||||
}
|
||||
catch ( ... ) {
|
||||
return WaveformProcessor::Error;
|
||||
}
|
||||
|
||||
for ( int i = 0; i < N; ++i ) {
|
||||
if ( comps[i] ) {
|
||||
if ( clipMask )
|
||||
comps[i]->setClipMask(clipMask.get());
|
||||
store(comps[i].get());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
status = WaveformProcessor::InProgress;
|
||||
|
||||
minStartTime = minEndTime;
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename T, int N, class PROC, int BSIZE>
|
||||
WaveformProcessor::Status NCompsOperator<T,N,PROC,BSIZE>::feed(const Record *rec) {
|
||||
if ( rec->data() == nullptr ) return WaveformProcessor::WaitingForData;
|
||||
|
||||
int i = _proc.compIndex(rec->channelCode());
|
||||
if ( i >= 0 ) {
|
||||
_states[i].buffer.feed(rec);
|
||||
return process(i, rec);
|
||||
}
|
||||
|
||||
return WaveformProcessor::WaitingForData;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename T, int N, class PROC, int BSIZE>
|
||||
void NCompsOperator<T,N,PROC,BSIZE>::reset() {
|
||||
// No reset while in processing
|
||||
if ( _processing ) return;
|
||||
|
||||
for ( int i = 0; i < N; ++i ) {
|
||||
_states[i] = State();
|
||||
}
|
||||
|
||||
_proc.reset();
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user