SCRUG-NA/2025
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[seiscomp, scanloc] Install, add .gitignore

Browse Source
This commit is contained in:
Dirk Rössler
2025-10-09 15:07:02 +02:00
commit 20f5301bb1
2848 changed files with 1315858 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

277
include/seiscomp/core/recordsequence.h Normal file
View File

@ -0,0 +1,277 @@
/***************************************************************************
* 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. *
***************************************************************************/
#ifndef SEISCOMP_RECORDSEQUENCE_H
#define SEISCOMP_RECORDSEQUENCE_H
#include <seiscomp/core/genericrecord.h>
#include <seiscomp/core/timewindow.h>
#include <deque>
namespace Seiscomp {
/**
* RecordSequence
*
* A container class for record sequences (i.e. records sorted in time)
* The class RecordSequence is a container for Record objects. It forms
* the basis for the implementation as RingBuffer or TimeWindowBuffer.
*/
class SC_SYSTEM_CORE_API RecordSequence : public std::deque<RecordCPtr> {
// ----------------------------------------------------------------------
// Public types
// ----------------------------------------------------------------------
public:
typedef std::deque<Core::TimeWindow> TimeWindowArray;
typedef std::pair<double,double> Range;
// ----------------------------------------------------------------------
// X'truction
// ----------------------------------------------------------------------
public:
//! C'tor
RecordSequence(double tolerance=0.5);
//! D'tor
virtual ~RecordSequence();
// ----------------------------------------------------------------------
// Public interface
// ----------------------------------------------------------------------
public:
//! Feed a record to buffer. Returns true if the record
//! was actually added.
virtual bool feed(const Record*) = 0;
//! Returns a copy of the sequence including all fed
//! records.
virtual RecordSequence *copy() const = 0;
//! Returns a cloned sequence without containing records.
virtual RecordSequence *clone() const = 0;
//! Return the time tolerance in samples
//! The tolerance is the maximum gap/overlap (in samples)
//! that will not break the continuity of the sequence.
double tolerance() const;
//! Set the time tolerance in samples
void setTolerance(double);
//! Return Record's as one contiguous record. Compiled in is support for
//! float, double and int. If interpolation is enabled gaps will be linearly
//! interpolated between the last and the next sample.
template <typename T>
GenericRecord *contiguousRecord(const Seiscomp::Core::TimeWindow *tw = nullptr,
bool interpolate = false) const;
//! DECPRECATED: For backward compatibility, does exactly the same as
//! contiguousRecord. Please use contiguousRecord in your
//! code. This method will be removed in future releases.
template <typename T>
GenericRecord *continuousRecord(const Seiscomp::Core::TimeWindow *tw = nullptr,
bool interpolate = false) const;
//! Time window currently in buffer, irrespective of gaps
Core::TimeWindow timeWindow() const;
//! The amplitude range in a given time window.
//! Returns (0,0) if the sequence is empty or no records fall inside
//! the given optional time window.
Range amplitudeRange(const Seiscomp::Core::TimeWindow *tw = nullptr) const;
//! returns the continuous time windows available
//! This is usually one time window but may be split into
//! several if there are any gaps.
TimeWindowArray windows() const;
//! returns the gaps that exceed dt *samples*
TimeWindowArray gaps() const;
//! Does the buffer contain all data for the time window?
bool contains(const Core::TimeWindow &tw) const;
//! Returns the percentage of available data within a given time window
double availability(const Core::TimeWindow& tw) const;
//! Returns the number of stored records, same as size().
size_t recordCount() const;
//! Determine average timing quality from the records stored in this
//! sequence.
//! Returns true on success; in that case, count and quality are set
bool timingQuality(int &count, float &quality) const;
// ----------------------------------------------------------------------
// Protected interface
// ----------------------------------------------------------------------
protected:
bool alreadyHasRecord(const Record*) const;
bool findInsertPosition(const Record*, iterator*);
// ----------------------------------------------------------------------
// Members
// ----------------------------------------------------------------------
protected:
double _tolerance;
};
/**
* TimeWindowBuffer
*
* A container class for record sequences (i.e. records sorted in time)
* The records are stored only if they at least overlap with the fixed time
* window. This is useful if only a certain fixed time window is of interest.
*/
class SC_SYSTEM_CORE_API TimeWindowBuffer : public RecordSequence {
// ----------------------------------------------------------------------
// X'truction
// ----------------------------------------------------------------------
public:
//! C'tor
TimeWindowBuffer(const Core::TimeWindow &tw, double tolerance=0.5);
// ----------------------------------------------------------------------
// Public RecordSequence interface overrides
// ----------------------------------------------------------------------
public:
virtual bool feed(const Record*);
virtual RecordSequence *copy() const;
virtual RecordSequence *clone() const;
// ----------------------------------------------------------------------
// Public interface
// ----------------------------------------------------------------------
public:
//! Return percentage of available data within TimeWindowBuffer's TimeWindow
double availability() const;
//! Return the buffered TimeWindow
const Core::TimeWindow &timeWindowToStore() const;
// ----------------------------------------------------------------------
// Members
// ----------------------------------------------------------------------
private:
Core::TimeWindow _timeWindow;
};
/**
* RingBuffer
*
* A container class for record sequences (i.e. records sorted in time)
* The records are stored only up to a maximum number; once this maximum
* number is reached, the oldest record is removed each time a new record is
* stored. Note that this doesn't usually guarantee a certain time window
* length.
*/
class SC_SYSTEM_CORE_API RingBuffer : public RecordSequence {
// ----------------------------------------------------------------------
// X'truction
// ----------------------------------------------------------------------
public:
//! Create RingBuffer for fixed maximum number of records
//! This version stores at most nmax most recent records.
RingBuffer(int nmax, double tolerance=0.5);
//! Create RingBuffer for fixed time span
//! This version stores at least a certain time
//! window length of available data ending at the
//! end time of the last record.
RingBuffer(Core::TimeSpan span, double tolerance=0.5);
// ----------------------------------------------------------------------
// Public RecordSequence interface overrides
// ----------------------------------------------------------------------
public:
virtual bool feed(const Record*);
virtual RecordSequence *copy() const;
virtual RecordSequence *clone() const;
// ----------------------------------------------------------------------
// Public interface
// ----------------------------------------------------------------------
public:
//! clear the buffer
void reset() { clear(); }
//! Return the maximum number of records the RingBuffer stores
unsigned int numberOfRecordsToStore() const;
//! Return the TimeSpan the RingBuffer stores
const Core::TimeSpan &timeSpanToStore() const;
// ----------------------------------------------------------------------
// Members
// ----------------------------------------------------------------------
private:
unsigned int _nmax;
Core::TimeSpan _span;
};
// ----------------------------------------------------------------------
// Inline implementations
// ----------------------------------------------------------------------
inline double RecordSequence::tolerance() const {
return _tolerance;
}
inline void RecordSequence::setTolerance(double dt) {
_tolerance = dt;
}
inline size_t RecordSequence::recordCount() const {
return size();
}
inline const Core::TimeWindow &TimeWindowBuffer::timeWindowToStore() const {
return _timeWindow;
}
inline unsigned int RingBuffer::numberOfRecordsToStore() const {
return _nmax;
}
inline const Core::TimeSpan &RingBuffer::timeSpanToStore() const {
return _span;
}
}
#endif