mspass::algorithms::SegmentVectorProperties Class Reference

Collaboration diagram for mspass::algorithms::SegmentVectorProperties:

Public Member Functions
	SegmentVectorProperties ()
	SegmentVectorProperties (const std::vector< TimeSeries > &segments)
	SegmentVectorProperties (const SegmentVectorProperties &parent)

Public Attributes
bool	dt_constant
bool	has_dead_components
bool	is_sorted
bool	has_overlaps
bool	has_gaps
int	number_live
int	first_live
double	t0
double	endtime
double	dt
size_t	spliced_nsamp
ErrorLogger	elog

Detailed Description

File scope class to enscapsulate set of possible data problems.

Merging multiple data segments to a single time series, which is a common need with continous data, is prone to a number of practical problems. Clock issues and the design of modern digitizers can cause a mismatch in time computed by dt*nsamp and data time tags with formats like miniseed. This can create apparent gaps or overlaps. This class is intended to be used to scan a vector of time-sorted segment to flag issues that need to be handled downstream in algorithms later in this file. Issues it addresses at present are:

1. irregular dt
2. segments marked dead
3. overlaps
4. gaps
5. Computes the length of the data being merged. Callers should test that that number is not absurd and could cause a memory alloc fault.

All attributes of this class are intentionally public as it should be thought of as a struct with convenient constructors.

Constructor & Destructor Documentation

SegmentVectorProperties() [1/3]

mspass::algorithms::SegmentVectorProperties::SegmentVectorProperties

(

)

Construct an empty property set with conservative defaults.

                                                 : elog() {
  dt_constant = true;
  has_dead_components = false;
  is_sorted = true;
  has_overlaps = false;
  has_gaps = false;
  number_live = 0;
  first_live = 0;
  t0 = 0.0;
  endtime = 0.0;
  dt = 0.0;
  spliced_nsamp = 0;
}

References dt, dt_constant, endtime, first_live, has_dead_components, has_gaps, has_overlaps, is_sorted, number_live, spliced_nsamp, and t0.

SegmentVectorProperties() [2/3]

mspass::algorithms::SegmentVectorProperties::SegmentVectorProperties

(

const std::vector< TimeSeries > &

segments

)

Scan a vector of segments and summarize ordering, gaps, overlaps, and size.

Parameters

segments

input segments to inspect before splicing.

                                           {
  /* Return a type conversion of the input when there is only one
  segment - nothing to splice in that case.  Error if it is empty */
  if (segments.size() == 1) {
    dt_constant = true;
    has_dead_components = false;
    is_sorted = true;
    has_overlaps = false;
    has_gaps = false;
    if (segments[0].live()) {
      number_live = 1;
      first_live = 0;
      t0 = segments[0].t0();
      endtime = segments[0].endtime();
      dt = segments[0].dt();
      this->spliced_nsamp = segments[0].npts();
    } else {
      number_live = 0;
      first_live = -1;
      t0 = 0.0;
      dt = 0.0;
      endtime = 0.0;
      this->spliced_nsamp = 0;
    }
  } else if (segments.size() == 0) {
    dt_constant = true;
    has_dead_components = false;
    is_sorted = true;
    has_overlaps = false;
    has_gaps = false;
    number_live = 0;
    first_live = -1;
    t0 = 0.0;
    dt = 0.0;
    endtime = 0.0;
    this->spliced_nsamp = 0;
  } else {
    double test_dt, dtfrac;
    double first_t0, previous_t0, previous_endtime;
    /* This algorithm requires the test above that guarantees number of segments
    is more than 1.  Some complexity to handle a dead member 0 is needed. */
    bool this_is_first(true);
    has_overlaps = false;
    is_sorted = true; // initialization
    has_dead_components = false;
    /* Declare a sample mismatch if nondimensional sample interval mismatch is
    less than this constant. */
    const double dt_fraction_mismatch(0.001);
    for (size_t i = 0; i < segments.size(); ++i) {
      if (segments[i].dead()) {
        has_dead_components = true;
        continue;
      }
      if (this_is_first) {
        this->dt_constant = true;
        this->first_live = i;
        first_t0 = segments[i].t0();
        previous_t0 = first_t0;
        test_dt = segments[i].dt();
        previous_endtime = segments[i].endtime();
        this_is_first = false;
        this->dt = test_dt;
        this->t0 = first_t0;
        this->number_live = 1;
      } else {
        /* This could be true multiple times if data were not sorted.
        Purpose of this boolean is to define a serious error condition
        that functions using this class must handle */
        if (segments[i].t0() < previous_t0)
          is_sorted = false;
        /* Test for overlaps - note sign is important */
        if ((previous_endtime + test_dt * TIME_TEAR_TOLERANCE) >
            segments[i].t0())
          has_overlaps = true;
        /* test for gaps */
        if ((segments[i].t0() - previous_endtime - test_dt) / test_dt >
            TIME_TEAR_TOLERANCE)
          has_gaps = true;
        /* Check for sample interval mismatch */
        dtfrac = fabs(segments[i].dt() - test_dt) / test_dt;
        if (dtfrac > dt_fraction_mismatch)
          dt_constant = false;
        previous_endtime = segments[i].endtime();
        previous_t0 = segments[i].t0();
        ++this->number_live;
      }
    }
    this->endtime = previous_endtime;
    this->spliced_nsamp = lround((previous_endtime - this->t0) / this->dt);
    ++this->spliced_nsamp; // nsamp is always one sample longer than intervals
  }
}

References dt, dt_constant, endtime, first_live, has_dead_components, has_gaps, has_overlaps, is_sorted, number_live, spliced_nsamp, and t0.

SegmentVectorProperties() [3/3]

mspass::algorithms::SegmentVectorProperties::SegmentVectorProperties

(

const SegmentVectorProperties &

parent

)

Standard copy constructor.

Parameters

parent

property set to copy.

    : elog(parent.elog) {
  dt_constant = parent.dt_constant;
  has_dead_components = parent.has_dead_components;
  is_sorted = parent.is_sorted;
  has_overlaps = parent.has_overlaps;
  has_gaps = parent.has_gaps;
  number_live = parent.number_live;
  first_live = parent.first_live;
  t0 = parent.t0;
  endtime = parent.endtime;
  dt = parent.dt;
  spliced_nsamp = parent.spliced_nsamp;
}

References dt, dt_constant, endtime, first_live, has_dead_components, has_gaps, has_overlaps, is_sorted, number_live, spliced_nsamp, and t0.

Member Data Documentation

dt

double mspass::algorithms::SegmentVectorProperties::dt

Sample interval used for the spliced output when dt is constant.

dt_constant

bool mspass::algorithms::SegmentVectorProperties::dt_constant

True when all live segments have the same sample interval.

elog

ErrorLogger mspass::algorithms::SegmentVectorProperties::elog

Messages formed while scanning input segments for downstream logging.

endtime

double mspass::algorithms::SegmentVectorProperties::endtime

Latest end time of the live segments.

first_live

int mspass::algorithms::SegmentVectorProperties::first_live

Index of the first live segment, or -1 when none are live.

has_dead_components

bool mspass::algorithms::SegmentVectorProperties::has_dead_components

True when at least one input segment is marked dead.

has_gaps

bool mspass::algorithms::SegmentVectorProperties::has_gaps

True when adjacent live segments have a gap beyond the time-tear tolerance.

has_overlaps

bool mspass::algorithms::SegmentVectorProperties::has_overlaps

True when adjacent live segments overlap beyond the time-tear tolerance.

is_sorted

bool mspass::algorithms::SegmentVectorProperties::is_sorted

True when live input segments are ordered by increasing start time.

number_live

int mspass::algorithms::SegmentVectorProperties::number_live

Number of live segments found in the input vector.

spliced_nsamp

size_t mspass::algorithms::SegmentVectorProperties::spliced_nsamp

Number of samples needed to hold the spliced output.

t0

double mspass::algorithms::SegmentVectorProperties::t0

Earliest start time of the live segments.

---

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

• /home/runner/work/mspass/mspass/cxx/src/lib/algorithms/splicing.cc